Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Einbetten mit Amazon Quick Sight APIs
<a name="embedded-analytics-api"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Der eigentliche Prozess der Einbettung von Analysen mithilfe von Amazon Quick Sight APIs umfasst nur wenige Schritte. 

Stellen Sie vor dem Beginn sicher, dass Sie über die folgenden Tools bereit haben:
+ Richten Sie die erforderlichen IAM-Berechtigungen für die Anruferidentität ein, die von Ihrer Anwendung verwendet wird, die das AWS SDK für API-Aufrufe verwendet. Erteilen Sie beispielsweise die Erlaubnis, die Aktion `quicksight:GenerateEmbedUrlForAnonymousUser` oder `quicksight:GenerateEmbedUrlForRegisteredUser` zuzulassen.
+ Um sie für registrierte Benutzer einzubetten, geben Sie Amazon Quick Sight-Ressourcen vorher an sie weiter. Neue Benutzer, die sich authentifizieren, sollten wissen, wie sie Zugriff auf die Ressourcen gewähren können. Eine Möglichkeit, dies zu tun, besteht darin, alle Assets zu einem Amazon Quick Sight-Ordner hinzuzufügen. Wenn Sie die Amazon Quick Sight-API bevorzugen, verwenden Sie die `UpdateDashboardPermissions` API-Operationen `DescribeDashboardPermissions` und. Weitere Informationen finden Sie unter [DescribeDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeDashboardPermissions.html)oder [UpdateDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateDashboardPermissions.html)in der *Amazon Quick API Reference*. Wenn Sie das Dashboard mit allen Benutzern in einem Namespace oder einer Gruppe teilen möchten, können Sie das Dashboard mit `namespace` oder `group` teilen.
+ Wenn Sie Dashboards einbetten, stellen Sie sicher, dass Sie die ID der Dashboards haben, die Sie einbetten möchten. Die Dashboard-ID ist der Code in der URL des Dashboards. Sie können ihn auch über die Dashboard-URL abrufen.
+ Ein Amazon Quick Sight-Administrator muss Domains, in die Sie Ihre Amazon Quick Sight-Analysen einbetten möchten, explizit aktivieren. Sie können dies tun, indem Sie **Amazon Quick Sight, **Domains and Embedding** verwalten** im Profilmenü verwenden, oder Sie können den `AllowedDomains` Parameter eines `GenerateEmbedUrlForAnonymousUser` oder `GenerateEmbedUrlForRegisteredUser` API-Aufrufs verwenden.

  Diese Option ist nur für Amazon Quick Sight-Administratoren sichtbar. Sie können auch Subdomains als Teil einer Domain hinzufügen. Weitere Informationen finden Sie unter [Erlauben Sie das Auflisten von Domains zur Laufzeit mit der Amazon Quick API](manage-domains.md#embedding-run-time).

  Alle Domains in Ihrer statischen Zulassungsliste (z. B. Entwicklung, Staging und Produktion) müssen explizit zugelassen sein und HTTPS verwenden. Sie können der Liste der zulässigen Domains bis zu 100 Domains hinzufügen. Mit Amazon Quick Sight API-Operationen können Sie Domains zur Laufzeit hinzufügen.

Nachdem alle Voraussetzungen erfüllt sind, umfasst das Einbetten von Amazon Quick Sight die folgenden Schritte, die später näher erläutert werden: 

1. Verwenden Sie zur Authentifizierung Ihren Anwendungsserver, um den Benutzer zu authentifizieren. Generieren Sie nach der Authentifizierung auf Ihrem Server die eingebettete Dashboard-URL mit dem AWS SDK, das Sie benötigen.

1. Binden Sie Amazon Quick Sight mithilfe der generierten URL in Ihr Webportal oder Ihre Anwendung ein. Um diesen Vorgang zu vereinfachen, können Sie das Amazon Quick Sight Embedding SDK verwenden, das auf [NPMJS](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) und verfügbar ist. [GitHub](https://github.com/awslabs/amazon-quicksight-embedding-sdk) Dieses maßgeschneiderte JavaScript SDK soll Ihnen helfen, Amazon Quick Sight effizient in Ihre Anwendungsseiten zu integrieren, Standardeinstellungen festzulegen, Steuerelemente zu verbinden, Rückrufe zu erhalten und Fehler zu behandeln. 

Sie können AWS CloudTrail Audit-Logs verwenden, um Informationen über die Anzahl der eingebetteten Dashboards, die Nutzer eines eingebetteten Erlebnisses und die Zugriffsraten zu erhalten.

**Topics**
+ [

# Einbetten von Amazon Quick Sight-Dashboards mit der Amazon Quick Sight API
](embedding-dashboards.md)
+ [

# Einbetten von Amazon Quick Sight-Grafiken mit Amazon Quick Sight APIs
](embedding-visuals.md)
+ [

# Einbetten der vollen Funktionalität der Amazon Quick Sight-Konsole für registrierte Benutzer
](embedded-analytics-full-console-for-authenticated-users.md)
+ [

# Einbetten von Amazon Q in Amazon Quick Sight Generatives Q&A-Erlebnis
](embedding-gen-bi.md)
+ [

# Einbetten der Amazon Quick Sight Q-Suchleiste (Classic)
](embedding-quicksight-q.md)
+ [

# Einbetten von Analysen mithilfe der GetDashboardEmbedURL- und GetSessionEmbedURL-API-Operationen
](embedded-analytics-deprecated.md)

# Einbetten von Amazon Quick Sight-Dashboards mit der Amazon Quick Sight API
<a name="embedding-dashboards"></a>

In den folgenden Themen erfahren Sie mehr über das Einbetten von Dashboards mit der Amazon Quick Sight API.

**Topics**
+ [

# Einbetten von Amazon Quick Sight-Dashboards für registrierte Benutzer
](embedded-analytics-dashboards-for-authenticated-users.md)
+ [

# Einbetten von Amazon Quick Sight-Dashboards für anonyme (nicht registrierte) Benutzer
](embedded-analytics-dashboards-for-everyone.md)
+ [

# Aktivieren von Zusammenfassungen in eingebetteten Dashboards
](embedded-analytics-genbi-executive-summaries-dashboard.md)

# Einbetten von Amazon Quick Sight-Dashboards für registrierte Benutzer
<a name="embedded-analytics-dashboards-for-authenticated-users"></a>

**Wichtig**  
Amazon Quick Sight verfügt über neue API-Operationen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin die Operationen `GetDashboardEmbedUrl` und `GetSessionEmbedUrl` API verwenden, um Dashboards und die Amazon Quick Sight-Konsole einzubetten, sie enthalten jedoch nicht die neuesten Einbettungsfunktionen. Weitere Informationen zum Einbetten mithilfe der alten API-Operationen finden Sie unter [Einbetten von Analysen mithilfe der GetDashboardEmbedURL](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html) API-Operationen und. GetSessionEmbedURL


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung eingebetteter Amazon Quick Sight-Dashboards für registrierte Benutzer von Amazon Quick Sight.

**Topics**
+ [

## Schritt 1: Festlegen von Berechtigungen
](#embedded-dashboards-for-authenticated-users-step-1)
+ [

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-dashboards-for-authenticated-users-step-2)
+ [

## Schritt 3: Einbetten der Dashboard-URL
](#embedded-dashboards-for-authenticated-users-step-3)

## Schritt 1: Festlegen von Berechtigungen
<a name="embedded-dashboards-for-authenticated-users-step-1"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf ein Dashboard zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für das Dashboard gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem. AWS-Konto Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Die IAM-Rolle muss Berechtigungen zum Abrufen von Einbettungen URLs für einen bestimmten Benutzerpool bereitstellen. Mithilfe des Platzhalterzeichens *\$1* können Sie die Berechtigungen zum Generieren einer URL für alle Benutzer in einem bestimmten Namespace oder für eine Teilmenge von Benutzern in bestimmten Namespaces gewähren. Dazu fügen Sie `quicksight:GenerateEmbedUrlForRegisteredUser` hinzu.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForRegisteredUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es gibt Ihnen als Entwickler die Möglichkeit, die statischen Domains zu überschreiben, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind. Stattdessen können Sie bis zu drei Domains oder Subdomains auflisten, die auf die generierte URL zugreifen können. Diese URL wird dann in die von Ihnen erstellte Website eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf die eingebettete Visualisierung zugreifen. Ohne diese Bedingung können Sie jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen.

Wenn Sie Erstbenutzer erstellen, die Amazon Quick Sight-Leser sein werden, stellen Sie außerdem sicher, dass Sie die `quicksight:RegisterUser` Erlaubnis in der Richtlinie hinzufügen.

Die folgende Beispielrichtlinie gewährt Erstbenutzern, die Amazon Quick Sight-Leser sein sollen, die Erlaubnis, eine Einbettungs-URL abzurufen.

Der IAM-Identität Ihrer Anwendung muss schließlich eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Das heißt, wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle im Namen des Benutzers übernehmen und den Benutzer in Amazon Quick Sight bereitstellen. Das folgende Beispiel zeigt eine Vertrauensrichtlinie. 

------
#### [ 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"
        }
    ]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien für die OpenId Connect- oder SAML-Authentifizierung finden Sie in den folgenden Abschnitten im *IAM-Benutzerhandbuch: *
+ [Erstellen von Rollen für Web-Identität oder OpenID Connect-Föderierung (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Erstellen von Rollen für die SAML 2.0-Föderierung (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-dashboards-for-authenticated-users-step-2"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Dashboard-URL auf Ihrem Anwendungsserver abrufen. Wenn Sie Dashboards für die Identitätstypen IAM oder Amazon Quick Sight einbetten möchten, teilen Sie das Dashboard mit den Benutzern.

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Durch die Ausführung dieser Schritte wird sichergestellt, dass jeder Viewer des Dashboards in Amazon Quick Sight eindeutig bereitgestellt wird. Dazu werden benutzerspezifische Einstellungen erzwungen, etwa Sicherheit auf niedriger Ebene sowie dynamische Standardwerte für Parameter.

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Dieser Code wird auf Ihrem App-Server ausgeführt.

### Java
<a name="embedded-dashboards-for-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
    import com.amazonaws.auth.BasicAWSCredentials;
    import com.amazonaws.auth.AWSCredentialsProvider;
    import com.amazonaws.regions.Regions;
    import com.amazonaws.services.quicksight.AmazonQuickSight;
    import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
    import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
    import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
    import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
    import com.amazonaws.services.quicksight.model.RegisteredUserDashboardEmbeddingConfiguration;

    /**
    * Class to call QuickSight AWS SDK to get url for dashboard embedding.
    */
    public class GetQuicksightEmbedUrlRegisteredUserDashboardEmbedding {

        private final AmazonQuickSight quickSightClient;

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

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

        public String getQuicksightEmbedUrl(
                final String accountId, // AWS Account ID
                final String dashboardId, // Dashboard ID to embed
                final List<String> allowedDomains, // Runtime allowed domain for embedding
                final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
        ) throws Exception {
            final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                    .withDashboard(new RegisteredUserDashboardEmbeddingConfiguration().withInitialDashboardId(dashboardId));
            final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
            generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
            generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
            generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
            generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

            final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

            return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
        }
    }
```

### JavaScript
<a name="embedded-dashboards-for-authenticated-users-js"></a>

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

    function generateEmbedUrlForRegisteredUser(
        accountId,
        dashboardId,
        openIdToken, // Cognito-based token
        userArn, // registered user arn
        roleArn, // IAM user role to use for embedding
        sessionName, // Session name for the roleArn assume role
        allowedDomains, // Runtime allowed domain for embedding
        getEmbedUrlCallback, // GetEmbedUrl success callback method
        errorCallback // GetEmbedUrl error callback method
        ) {
        const stsClient = new AWS.STS();
        let stsParams = {
            RoleSessionName: sessionName,
            WebIdentityToken: openIdToken,
            RoleArn: roleArn
        }

        stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
            if (err) {
                console.log('Error assuming role');
                console.log(err, err.stack);
                errorCallback(err);
            } else {
                const getDashboardParams = {
                    "AwsAccountId": accountId,
                    "ExperienceConfiguration": {
                        "Dashboard": {
                            "InitialDashboardId": dashboardId
                        }
                    },
                    "UserArn": userArn,
                    "AllowedDomains": allowedDomains,
                    "SessionLifetimeInMinutes": 600
                };

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

                quicksightClient.generateEmbedUrlForRegisteredUser(getDashboardParams, function(err, data) {
                    if (err) {
                        console.log(err, err.stack);
                        errorCallback(err);
                    } else {
                        const result = {
                            "statusCode": 200,
                            "headers": {
                                "Access-Control-Allow-Origin": "*", // Use your website domain to secure access to GetEmbedUrl API
                                "Access-Control-Allow-Headers": "Content-Type"
                            },
                            "body": JSON.stringify(data),
                            "isBase64Encoded": false
                        }
                        getEmbedUrlCallback(result);
                    }
                });
            }
        });
    }
```

### Python3
<a name="embedded-dashboards-for-authenticated-users-py"></a>

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

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# dashboardId: Dashboard ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, dashboardId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    "Dashboard": {
                        "InitialDashboardId": dashboardId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-dashboards-for-authenticated-users-node"></a>

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

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

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

    quicksightClient.generateEmbedUrlForRegisteredUser({
        'AwsAccountId': '111122223333',
        'ExperienceConfiguration': { 
            'Dashboard': {
                'InitialDashboardId': '1c1fe111-e2d2-3b30-44ef-a0e111111cde'
            }
        },
        'UserArn': 'REGISTERED_USER_ARN',
        'AllowedDomains': allowedDomains,
        'SessionLifetimeInMinutes': 100
    }, function(err, data) {
        console.log('Errors: ');
        console.log(err);
        console.log('Response: ');
        console.log(data);
    });
```

**Example**  

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

### .NET/C\$1
<a name="embedded-dashboards-for-authenticated-users-cs"></a>

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

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

    namespace GenerateDashboardEmbedUrlForRegisteredUser
    {
        class Program
        {
            static void Main(string[] args)
            {
                var quicksightClient = new AmazonQuickSightClient(
                    AccessKey,
                    SecretAccessKey,
                    SessionToken,
                    Amazon.RegionEndpoint.USEast1);
                try
                {
                    RegisteredUserDashboardEmbeddingConfiguration registeredUserDashboardEmbeddingConfiguration
                        = new RegisteredUserDashboardEmbeddingConfiguration
                        {
                            InitialDashboardId = "dashboardId"
                        };
                    RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                        = new RegisteredUserEmbeddingExperienceConfiguration
                        {
                            Dashboard = registeredUserDashboardEmbeddingConfiguration
                        };
                        
                    Console.WriteLine(
                        quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                        {
                            AwsAccountId = "111122223333",
                            ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                            UserArn = "REGISTERED_USER_ARN",
                            AllowedDomains = allowedDomains,
                            SessionLifetimeInMinutes = 100
                        }).Result.EmbedUrl
                    );
                } catch (Exception ex) {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
```

### AWS CLI
<a name="embedded-dashboards-for-authenticated-users-cli"></a>

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForRegisteredUser` aktiviert sein. Wenn Sie Benutzer hinzufügen möchten, wenn diese ein just-in-time Dashboard zum ersten Mal öffnen, müssen für die Rolle auch die entsprechenden Berechtigungen aktiviert sein. `quicksight:RegisterUser`

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGANGSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_dashboard_role/john.doe@example.com`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. *Throttling* ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. 

Die Rollensitzungs-ID wird auch zum Benutzernamen in Amazon Quick Sight. Sie können dieses Muster verwenden, um Ihre Benutzer im Voraus in Amazon Quick Sight bereitzustellen oder um sie beim ersten Zugriff auf das Dashboard bereitzustellen. 

Das folgende Beispiel zeigt den CLI-Befehl, den Sie verwenden können, um einen Benutzer bereitstellen. Weitere Informationen zu [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), und anderen Amazon Quick Sight API-Vorgängen finden Sie in der [Amazon Quick Sight API-Referenz](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html).

```
aws quicksight register-user \
        --aws-account-id 111122223333 \
        --namespace default \
        --identity-type IAM \
        --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
        --user-role READER \
        --user-name jhnd \
        --session-name "john.doe@example.com" \
        --email john.doe@example.com \
        --region us-east-1 \
        --custom-permissions-name TeamA1
```

Wenn Ihr Benutzer durch Microsoft AD authentifiziert wird, müssen Sie `RegisterUser` nicht verwenden, um sie einzurichten. Stattdessen sollten sie beim ersten Zugriff auf Amazon Quick Sight automatisch abonniert werden. Für Microsoft AD-Benutzer können Sie `DescribeUser` verwenden, um den Benutzer ARN zu erhalten.

Wenn ein Benutzer zum ersten Mal auf Amazon Quick Sight zugreift, können Sie diesen Benutzer auch zu der Gruppe hinzufügen, mit der das Dashboard geteilt wird. Das folgende Beispiel zeigt den CLI-Befehl zum Hinzufügen eines Benutzers zu einer Gruppe.

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

Sie haben jetzt einen Benutzer Ihrer App, der auch Amazon Quick Sight verwendet und Zugriff auf das Dashboard hat. 

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie schließlich `generate-embed-url-for-registered-user` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die über AWS Managed Microsoft AD oder Single Sign-On (IAM Identity Center) authentifiziert wurden.

```
aws quicksight generate-embed-url-for-registered-user \
        --aws-account-id 111122223333 \
        --session-lifetime-in-minutes 600 \
        --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_visual_role/embeddingsession \
        --allowed-domains '["domain1","domain2"]' \
        --experience-configuration Dashboard={InitialDashboardId=1a1ac2b2-3fc3-4b44-5e5d-c6db6778df89}
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden.

## Schritt 3: Einbetten der Dashboard-URL
<a name="embedded-dashboards-for-authenticated-users-step-3"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die Dashboard-URL aus Schritt 3 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren des Dashboards auf einer HTML-Seite.
+ Übergeben von Parameter in das Dashboard.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForRegisteredUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für bis zu 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code` bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-registered-user`:

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

Betten Sie dieses Dashboard mithilfe des [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) in Ihre Webseite ein oder fügen Sie diese URL zu einem Iframe hinzu. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter im Dashboard steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Die Domain, die als Host für die eingebetteten Dashboards dienen soll, muss in der *Zulassungsliste* (allow list) stehen, der Liste zulässiger Domains für das Quick -Abonnement. Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Dashboards zu hosten. Weitere Informationen zum Hinzufügen von Domains für eingebettete Dashboards finden Sie unter [Zulassen, dass Domains zur Laufzeit mit der Amazon Quick Sight API](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) aufgelistet werden.

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

### SDK 2.0
<a name="embedded-dashboards-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

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

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

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

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

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

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

</html>
```

### SDK 1.0
<a name="embedded-dashboards-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

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

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

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

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

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

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Dashboard auf Ihre Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

# Einbetten von Amazon Quick Sight-Dashboards für anonyme (nicht registrierte) Benutzer
<a name="embedded-analytics-dashboards-for-everyone"></a>

**Wichtig**  
Amazon Quick Sight verfügt über neue API-Operationen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin die Operationen `GetDashboardEmbedUrl` und `GetSessionEmbedUrl` API verwenden, um Dashboards und die Amazon Quick Sight-Konsole einzubetten, sie enthalten jedoch nicht die neuesten Einbettungsfunktionen. Weitere Informationen zum Einbetten mithilfe der alten API-Operationen finden Sie unter [Einbetten von Analysen mithilfe der GetDashboardEmbedURL](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html) API-Operationen und. GetSessionEmbedURL


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung eingebetteter Amazon Quick Sight-Dashboards für anonyme (nicht registrierte) Benutzer.

**Topics**
+ [

## Schritt 1: Festlegen von Berechtigungen
](#embedded-analytics-dashboards-with-anonymous-users-step-1)
+ [

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-analytics-dashboards-with-anonymous-users-step-2)
+ [

## Schritt 3: Einbetten der Dashboard-URL
](#embedded-analytics-dashboards-with-anonymous-users-step-3)

## Schritt 1: Festlegen von Berechtigungen
<a name="embedded-analytics-dashboards-with-anonymous-users-step-1"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf ein Dashboard zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für das Dashboard gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem. AWS-Konto Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForAnonymousUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es gibt Ihnen als Entwickler die Möglichkeit, die statischen Domains zu überschreiben, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind. Stattdessen können Sie bis zu drei Domains oder Subdomains auflisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die von Ihnen erstellte Website eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf das eingebettete Dashboard zugreifen. Ohne diese Bedingung können Sie jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen zur Verwendung mit `GenerateEmbedUrlForAnonymousUser`. Damit dieser Ansatz funktioniert, benötigen Sie auch ein Sitzungspaket oder eine Preisgestaltung für Sitzungskapazität für Ihre AWS-Konto. Andernfalls wird der Fehler `UnsupportedPricingPlanException` zurückgegeben, wenn ein Benutzer versucht, auf das Dashboard zuzugreifen. 

Der IAM-Identität Ihrer Anwendung muss eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Dies bedeutet: Wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle für den Benutzer übernehmen, um das Dashboard zu öffnen. Das folgende Beispiel zeigt eine Vertrauensrichtlinie.

------
#### [ 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"
    }
]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien finden Sie unter [Temporäre Sicherheitsanmeldeinformationen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*.

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-analytics-dashboards-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie im Namen des anonymen Besuchers authentifizieren und die einbettungsfähige Dashboard-URL auf Ihrem Anwendungsserver abrufen. 

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Es wird eine ID als eindeutige Rollensitzungs-ID übergeben. Dieser Code wird auf Ihrem App-Server ausgeführt.

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

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

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

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

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

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

**Example**  

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

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

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

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

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie Security Assertion Markup Language (SAML) zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForAnonymousUser` aktiviert sein. 

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGRIFFSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_dashboard_role/QuickSightEmbeddingAnonymousPolicy`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass für jeden besuchenden Benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird jede Sitzung getrennt und unterschiedlich gehalten. Wenn Sie eine Reihe von Webservern verwenden, z. B. für den Lastenausgleich, und eine Sitzung erneut mit einem anderen Server verbunden wird, beginnt eine neue Sitzung.

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie `generate-embed-url-for-anynymous-user` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die Ihr Webportal oder Ihre App anonym besuchen.

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

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden. 

## Schritt 3: Einbetten der Dashboard-URL
<a name="embedded-analytics-dashboards-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die Dashboard-URL aus Schritt 2 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren des Dashboards auf einer HTML-Seite.
+ Übergeben von Parameter in das Dashboard.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForAnynymousUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code` bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `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"
        }
```

Betten Sie dieses Dashboard mithilfe des [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) in Ihre Webseite ein oder fügen Sie diese URL zu einem Iframe hinzu. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter im Dashboard steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Die Domain, die als Host für die eingebetteten Dashboards dienen soll, muss in der *Zulassungsliste* (allow list) stehen, der Liste zulässiger Domains für das Quick -Abonnement. Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Dashboards zu hosten. Weitere Informationen zum Hinzufügen von Domains für eingebettete Dashboards finden Sie unter [Zulassen, dass Domains zur Laufzeit mit der Amazon Quick Sight API](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) aufgelistet werden.

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code befindet sich auf Ihrem App-Server.

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

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Dashboard auf Ihre Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des Amazon Quick Sight Embedding SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

# Aktivieren von Zusammenfassungen in eingebetteten Dashboards
<a name="embedded-analytics-genbi-executive-summaries-dashboard"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Sie können Zusammenfassungen in Ihren eingebetteten Dashboards aktivieren. Wenn diese Option aktiviert ist, können registrierte Benutzer Zusammenfassungen erstellen, die eine Zusammenfassung aller Erkenntnisse enthalten, die Amazon Quick Sight für das Dashboard generiert hat. Zusammenfassungen erleichtern es den Lesern, wichtige Erkenntnisse und Informationen zu einem Dashboard zu finden. Weitere Informationen darüber, wie Benutzer eine Zusammenfassung eines Dashboards erstellen, finden Sie unter [Generieren einer Zusammenfassung eines Amazon Quick Sight-Dashboards](https://docs.aws.amazon.com/quicksight/latest/user/use-executive-summaries.html).

**Anmerkung**  
Zusammenfassungen sind nur in eingebetteten Dashboards für registrierte Benutzer verfügbar und können in eingebetteten Dashboards für anonyme oder nicht registrierte Benutzer nicht aktiviert werden.

**So aktivieren Sie Zusammenfassungen in eingebetteten Dashboards für registrierte Benutzer**
+ Folgen Sie den Schritten unter [Amazon Quick Sight-Dashboards für registrierte Benutzer](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-dashboards-for-authenticated-users.html) einbetten, um ein Dashboard mit den folgenden Änderungen einzubetten:

  1. Wenn Sie die URL in Schritt 2 generieren, geben Sie `Enabled: true` den `ExecutiveSummary` Parameter im [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)oder ein, [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html)wie im folgenden Beispiel gezeigt:

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

  1. Wenn Sie die Dashboard-URL mit dem Amazon Quick Sight Embedding SDK in Schritt 3 einbetten, legen Sie `executiveSummary: true` Folgendes fest`contentOptions`, wie im folgenden Beispiel gezeigt:

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

# Einbetten von Amazon Quick Sight-Grafiken mit Amazon Quick Sight APIs
<a name="embedding-visuals"></a>

Mit der Amazon Quick Sight-API können Sie einzelne Grafiken, die Teil eines veröffentlichten Dashboards sind, in Ihre Anwendung einbetten.

**Topics**
+ [

# Einbetten von Amazon Quick Sight-Grafiken für registrierte Benutzer
](embedded-analytics-visuals-for-authenticated-users.md)
+ [

# Einbetten von Amazon Quick Sight-Grafiken für anonyme (nicht registrierte) Benutzer
](embedded-analytics-visuals-for-everyone.md)

# Einbetten von Amazon Quick Sight-Grafiken für registrierte Benutzer
<a name="embedded-analytics-visuals-for-authenticated-users"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung eingebetteter Amazon Quick Sight-Grafiken für registrierte Benutzer von Amazon Quick Sight.

**Topics**
+ [

## Schritt 1: Festlegen von Berechtigungen
](#embedded-visuals-for-authenticated-users-step-1)
+ [

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-visuals-for-authenticated-users-step-2)
+ [

## Schritt 3: Betten Sie die Visualisierung-URL ein
](#embedded-visuals-for-authenticated-users-step-3)

## Schritt 1: Festlegen von Berechtigungen
<a name="embedded-visuals-for-authenticated-users-step-1"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf ein Visual zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für das Visual gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem. AWS-Konto Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Die IAM-Rolle muss Berechtigungen zum Abrufen von Einbettungen URLs für einen bestimmten Benutzerpool bereitstellen. Mithilfe des Platzhalterzeichens *\$1* können Sie die Berechtigungen zum Generieren einer URL für alle Benutzer in einem bestimmten Namespace oder für eine Teilmenge von Benutzern in bestimmten Namespaces gewähren. Dazu fügen Sie `quicksight:GenerateEmbedUrlForRegisteredUser` hinzu.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForAnonymousUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es gibt Ihnen als Entwickler die Möglichkeit, die statischen Domains zu überschreiben, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind. Stattdessen können Sie bis zu drei Domains oder Subdomains auflisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die von Ihnen erstellte Website eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf das eingebettete Dashboard zugreifen. Ohne diese Bedingung können Sie jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen.

Wenn Sie Erstbenutzer erstellen, die Amazon Quick Sight-Leser sein werden, stellen Sie außerdem sicher, dass Sie die `quicksight:RegisterUser` Erlaubnis in der Richtlinie hinzufügen.

Die folgende Beispielrichtlinie gewährt Erstbenutzern, die Amazon Quick Sight-Leser sein sollen, die Erlaubnis, eine Einbettungs-URL abzurufen.

Der IAM-Identität Ihrer Anwendung muss schließlich eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Das heißt, wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle im Namen des Benutzers übernehmen und den Benutzer in Amazon Quick Sight bereitstellen. Das folgende Beispiel zeigt eine Vertrauensrichtlinie.

------
#### [ 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"
        }
    ]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien für die OpenId Connect- oder SAML-Authentifizierung finden Sie in den folgenden Abschnitten im *IAM-Benutzerhandbuch: *
+ [Erstellen von Rollen für Web-Identität oder OpenID Connect-Föderierung (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Erstellen von Rollen für die SAML 2.0-Föderierung (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-visuals-for-authenticated-users-step-2"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Amazon Quick Sight-Benutzer authentifizieren und die einbettbare visuelle URL auf Ihrem Anwendungsserver abrufen können. Wenn Sie Grafiken für die Identitätstypen IAM oder Amazon Quick Sight einbetten möchten, teilen Sie das Bild mit den Amazon Quick Sight-Benutzern.

Wenn ein Amazon Quick Sight-Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle im Namen des Amazon Quick Sight-Benutzers. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Amazon Quick Sight-Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Durch die Ausführung der beschriebenen Schritte wird sichergestellt, dass jeder Betrachter des Visuals eindeutig in Amazon Quick Sight bereitgestellt wird. Dazu werden benutzerspezifische Einstellungen erzwungen, etwa Sicherheit auf niedriger Ebene sowie dynamische Standardwerte für Parameter.

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Amazon Quick Sight-Benutzers durchgeführt. Dieser Code wird auf Ihrem App-Server ausgeführt.

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

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

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

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

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

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS) aus:
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForRegisteredUser` aktiviert sein. Wenn Sie Benutzer hinzufügen möchten, wenn diese ein just-in-time Dashboard zum ersten Mal öffnen, müssen für die Rolle auch die entsprechenden Berechtigungen aktiviert sein. `quicksight:RegisterUser`

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGRIFFSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_visual_role/john.doe@example.com`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. *Throttling* ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. 

Die Rollensitzungs-ID wird auch zum Benutzernamen in Amazon Quick Sight. Sie können dieses Muster verwenden, um Ihre Benutzer im Voraus in Amazon Quick Sight bereitzustellen oder um sie beim ersten Zugriff auf das Dashboard bereitzustellen. 

Das folgende Beispiel zeigt den CLI-Befehl, den Sie verwenden können, um einen Benutzer bereitstellen. Weitere Informationen zu [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), und anderen Amazon Quick Sight API-Vorgängen finden Sie in der [Amazon Quick Sight API-Referenz](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
```

Wenn der Benutzer durch Microsoft AD authentifiziert wird, müssen Sie `RegisterUser` nicht verwenden, um sie einzurichten. Stattdessen sollten sie automatisch abonniert werden, wenn sie zum ersten Mal auf Amazon Quick Sight zugreifen. Für Microsoft AD-Benutzer können Sie `DescribeUser` verwenden, um den Benutzer ARN zu erhalten.

Wenn ein Benutzer zum ersten Mal auf Amazon Quick Sight zugreift, können Sie ihn auch zu der Gruppe hinzufügen, mit der das Bild geteilt wird. Das folgende Beispiel zeigt den CLI-Befehl zum Hinzufügen eines Benutzers zu einer Gruppe.

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

Sie haben jetzt einen Benutzer Ihrer App, der auch Amazon Quick Sight verwendet und Zugriff auf das Visual hat. 

Um eine signierte URL für die Visualisierung zu erhalten, rufen Sie schließlich `generate-embed-url-for-registered-user` vom App-Server auf. Dies gibt die einbettungsfähige Visualisierungs-URL zurück. Das folgende Beispiel zeigt, wie die URL für ein eingebettetes Visual mithilfe eines serverseitigen Aufrufs für Benutzer generiert wird, die über AWS Managed Microsoft AD oder Single Sign-On (IAM Identity Center) authentifiziert wurden.

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

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden.

## Schritt 3: Betten Sie die Visualisierung-URL ein
<a name="embedded-visuals-for-authenticated-users-step-3"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die visuelle URL aus Schritt 3 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie die Visualisierung auf einer HTML-Seite.
+ Übergeben Sie Parameter an die Visualisierung.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForRegisteredUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für bis zu 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code` bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-registered-user`: `quicksightdomain`In diesem Beispiel ist das die URL, die Sie für den Zugriff auf Ihr Amazon Quick Sight-Konto verwenden.

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

Betten Sie dieses Bild in Ihre Webseite ein, indem Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) verwenden oder indem Sie diese URL zu einem Iframe hinzufügen. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter innerhalb der Grafik steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Die Domain, die eingebettete Grafiken und Dashboards hosten soll, muss auf der *Zulassungsliste stehen, der Liste* der zugelassenen Domains für Ihr Abonnement. Quick Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Visualisierungen und Dashboards zu hosten. Weitere Informationen zum Hinzufügen von Domains für eingebettete Grafiken und Dashboards finden Sie unter [Zulassen, dass Domains zur Laufzeit mit der Amazon Quick Sight API aufgelistet](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) werden.

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

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

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Bild auf Ihre Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

# Einbetten von Amazon Quick Sight-Grafiken für anonyme (nicht registrierte) Benutzer
<a name="embedded-analytics-visuals-for-everyone"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung eingebetteter Amazon Quick Sight-Grafiken für anonyme (nicht registrierte) Benutzer.

**Topics**
+ [

## Schritt 1: Festlegen von Berechtigungen
](#embedded-analytics-visuals-with-anonymous-users-step-1)
+ [

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-analytics-visuals-with-anonymous-users-step-2)
+ [

## Schritt 3: Betten Sie die Visualisierung-URL ein
](#embedded-analytics-visuals-with-anonymous-users-step-3)

## Schritt 1: Festlegen von Berechtigungen
<a name="embedded-analytics-visuals-with-anonymous-users-step-1"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf ein Visual zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für das Visual gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem. AWS-Konto Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForAnonymousUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es gibt Ihnen als Entwickler die Möglichkeit, die statischen Domains zu überschreiben, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind. Stattdessen können Sie bis zu drei Domains oder Subdomains auflisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die von Ihnen erstellte Website eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf das eingebettete Dashboard zugreifen. Ohne diese Bedingung können Sie jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Der IAM-Identität Ihrer Anwendung muss eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Dies bedeutet: Wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle für den Benutzer übernehmen, um die Visualisierung zu öffnen. Das folgende Beispiel zeigt eine Vertrauensrichtlinie.

------
#### [ 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"
        }
    ]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien finden Sie unter [Temporäre Sicherheitsanmeldeinformationen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*.

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-analytics-visuals-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie im Namen des anonymen Besuchers authentifizieren und die einbettungsfähige Visualisierung-URL auf Ihrem Anwendungsserver abrufen.

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Es wird eine ID als eindeutige Rollensitzungs-ID übergeben. Dieser Code wird auf Ihrem App-Server ausgeführt.

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

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

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

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

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

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS) aus:
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie Security Assertion Markup Language (SAML) zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForAnonymousUser` aktiviert sein. 

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGRIFFSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_visual_role/QuickSightEmbeddingAnonymousPolicy`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass für jeden besuchenden Benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird jede Sitzung getrennt und unterschiedlich gehalten. Wenn Sie eine Reihe von Webservern verwenden, z. B. für den Lastenausgleich, und eine Sitzung erneut mit einem anderen Server verbunden wird, beginnt eine neue Sitzung.

Um eine signierte URL für die Visualisierung zu erhalten, rufen Sie `generate-embed-url-for-anynymous-user` vom App-Server auf. Dies gibt die einbettungsfähige Visualisierungs-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für eine eingebettete Visualisierung mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die Ihr Webportal oder Ihre App anonym besuchen.

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

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden. 

## Schritt 3: Betten Sie die Visualisierung-URL ein
<a name="embedded-analytics-visuals-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die visuelle URL aus Schritt 2 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie die Visualisierung auf einer HTML-Seite.
+ Übergeben Sie Parameter an die Visualisierung.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForAnonymousUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für 10 Stunden. Die API-Operation stellt die URL mit einem Autorisierungscode (auth) bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-anonymous-user`: `quicksightdomain`In diesem Beispiel ist das die URL, die Sie für den Zugriff auf Ihr Amazon Quick Sight-Konto verwenden.

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

Betten Sie dieses Bild in Ihre Webseite ein, indem Sie das Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) verwenden oder indem Sie diese URL zu einem Iframe hinzufügen. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter innerhalb des Visuals steuern und Rückrufe in Bezug auf den Abschluss des visuellen Ladevorgangs und Fehler erhalten. 

Die Domain, die als Host für die eingebettete Visualisierung dienen soll, muss in der *allow list* (Zulassungsliste) stehen, der Liste zulässiger Domains für das Quick -Abonnement. Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Visualisierungen und Dashboards zu hosten. Weitere Informationen zum Hinzufügen von Domains für eingebettete Grafiken und Dashboards finden Sie unter [Zulassen, dass Domains zur Laufzeit mit der Amazon Quick Sight API aufgelistet](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) werden.

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code befindet sich auf Ihrem App-Server.

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

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Bild auf Ihre Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des QuickSight eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

# Einbetten der vollen Funktionalität der Amazon Quick Sight-Konsole für registrierte Benutzer
<a name="embedded-analytics-full-console-for-authenticated-users"></a>

**Wichtig**  
Amazon Quick Sight verfügt über neue API-Operationen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin die Operationen `GetDashboardEmbedUrl` und `GetSessionEmbedUrl` API verwenden, um Dashboards und die Amazon Quick Sight-Konsole einzubetten, sie enthalten jedoch nicht die neuesten Einbettungsfunktionen. Weitere Informationen zum Einbetten mithilfe der alten API-Operationen finden Sie unter [Einbetten von Analysen mithilfe der GetDashboardEmbedURL](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html) API-Operationen und. GetSessionEmbedURL


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Mit der Enterprise Edition können Sie nicht nur lesbare Dashboards bereitstellen, sondern auch die Amazon Quick Sight-Konsole in einem maßgeschneiderten Autorenportal bereitstellen. Mit diesem Ansatz ermöglichen Sie Ihren Benutzern die Erstellung von Datenquellen, Datensätzen und Analysen. In derselben Oberfläche können sie Dashboards erstellen, veröffentlichen und anzeigen. Wenn Sie einige dieser Berechtigungen einschränken möchten, können Sie dies auch tun.

Benutzer, die über eine eingebettete Konsole auf Amazon Quick Sight zugreifen, müssen der Autoren- oder Administrator-Sicherheitskohorte angehören. Leser haben nicht genügend Zugriff, um die Amazon Quick Sight-Konsole für das Authoring zu verwenden, unabhängig davon, ob sie eingebettet ist oder Teil von. AWS-Managementkonsole Autoren und Administratoren können jedoch weiterhin auf eingebettete Dashboards zugreifen. Wenn Sie die Berechtigungen für einige der Authoring-Funktionen einschränken möchten, können Sie dem Benutzer mit der [UpdateUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateUser.html)API-Operation ein benutzerdefiniertes Berechtigungsprofil hinzufügen. Verwenden Sie den [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)API-Vorgang, um einen neuen Benutzer mit einem angehängten benutzerdefinierten Berechtigungsprofil hinzuzufügen. Weitere Informationen finden Sie in den folgenden Abschnitten:
+ Informationen zum Erstellen benutzerdefinierter Rollen durch die Definition benutzerdefinierter Konsolenberechtigungen finden Sie unter [Anpassen des Zugriffs auf die Amazon Quick Sight-Konsole](https://docs.aws.amazon.com/quicksight/latest/user/customizing-permissions-to-the-quicksight-console.html).
+ [Informationen zur Verwendung von Namespaces zur Isolierung von Benutzern, Gruppen und Amazon Quick Sight-Assets mit mehreren Mandanten finden Sie unter Amazon Quick Sight Namespaces.](https://docs.aws.amazon.com/quicksight/latest/APIReference/controlling-access.html#namespaces.html)
+ Informationen zum Hinzufügen Ihres eigenen Brandings zu einer eingebetteten Amazon Quick Sight-Konsole finden Sie [unter Themes in Amazon Quick Sight verwenden](https://docs.aws.amazon.com/quicksight/latest/user/themes-in-quicksight.html) und [QuickSight Theme-API-Operationen](https://docs.aws.amazon.com/quicksight/latest/APIReference/qs-assets.html#themes). 

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung eingebetteter Amazon Quick Sight-Dashboards für registrierte Benutzer.

**Topics**
+ [

## Schritt 1: Festlegen von Berechtigungen
](#embedded-analytics-full-console-for-authenticated-users-step-1)
+ [

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-analytics-full-console-for-authenticated-users-step-2)
+ [

## Schritt 3: Betten Sie die URL der Konsolensitzung ein
](#embedded-analytics-full-console-for-authenticated-users-step-3)
+ [

# Aktivieren der Features generativer BI in eingebetteten Konsolen für registrierte Benutzer
](embedding-consoles-genbi.md)

## Schritt 1: Festlegen von Berechtigungen
<a name="embedded-analytics-full-console-for-authenticated-users-step-1"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf Amazon Quick Sight zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für die Konsolensitzung gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem AWS Konto. Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Fügen Sie `quicksight:RegisterUser` Berechtigungen hinzu, um sicherzustellen, dass der Leser nur lesend auf Amazon Quick Sight zugreifen kann und keinen Zugriff auf andere Daten oder Erstellungsfunktionen hat. Die IAM-Rolle muss außerdem Berechtigungen zum Abrufen der Konsolensitzung bereitstellen. URLs Dazu fügen Sie `quicksight:GenerateEmbedUrlForRegisteredUser` hinzu.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForAnonymousUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es gibt Ihnen als Entwickler die Möglichkeit, die statischen Domains zu überschreiben, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind. Stattdessen können Sie bis zu drei Domains oder Subdomains auflisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die von Ihnen erstellte Website eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf das eingebettete Dashboard zugreifen. Ohne diese Bedingung können Sie jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen. 

Die folgende Beispielrichtlinie gewährt die Berechtigung zum Abrufen einer Konsolensitzungs-URL. Sie können die Richtlinie auch ohne `quicksight:RegisterUser` verwenden, wenn Sie Benutzer erstellen, bevor sie auf eine eingebettete Sitzung zugreifen.

Der IAM-Identität Ihrer Anwendung muss schließlich eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Das heißt, wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle im Namen des Benutzers übernehmen und den Benutzer in Amazon Quick Sight bereitstellen. Das folgende Beispiel zeigt eine Vertrauensrichtlinie. 

------
#### [ 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"
        }
    ]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien für die OpenId Connect- oder SAML-Authentifizierung finden Sie in den folgenden Abschnitten im *IAM-Benutzerhandbuch: *
+ [Erstellen von Rollen für Web-Identität oder OpenID Connect-Föderierung (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Erstellen von Rollen für die SAML 2.0-Föderierung (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-analytics-full-console-for-authenticated-users-step-2"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Konsolensitzung-URL auf Ihrem Anwendungsserver abrufen. 

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Durch die Ausführung der beschriebenen Schritte wird sichergestellt, dass jeder Viewer der Konsolensitzung in Amazon Quick Sight eindeutig bereitgestellt wird. Dazu werden benutzerspezifische Einstellungen erzwungen, etwa Sicherheit auf niedriger Ebene sowie dynamische Standardwerte für Parameter.

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Dieser Code wird auf Ihrem App-Server ausgeführt.

### Java
<a name="embedded-analytics-full-console-for-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserQuickSightConsoleEmbeddingConfiguration;

/**
 * Class to call QuickSight AWS SDK to get url for QuickSight console embedding.
 */
public class GetQuicksightEmbedUrlRegisteredUserQSConsoleEmbedding {

    private final AmazonQuickSight quickSightClient;

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

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

    public String getQuicksightEmbedUrl(
            final String accountId,
            final String userArn, // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String initialPath
    ) throws Exception {
        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withQuickSightConsole(new RegisteredUserQuickSightConsoleEmbeddingConfiguration().withInitialPath(initialPath));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

        return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
    }
}
```

### JavaScript
<a name="embedded-analytics-full-console-for-authenticated-users-js"></a>

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

function generateEmbedUrlForRegisteredUser(
    accountId,
    dashboardId,
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    getEmbedUrlCallback, // GetEmbedUrl success callback method
    errorCallback // GetEmbedUrl error callback method
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
    }

    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getDashboardParams = {
                "AwsAccountId": accountId,
                "ExperienceConfiguration": {
                    "QuickSightConsole": {
                        "InitialPath": '/start'
                    }
                },
                "UserArn": userArn,
                "AllowedDomains": allowedDomains,
                "SessionLifetimeInMinutes": 600
            };

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

            quicksightGetDashboard.generateEmbedUrlForRegisteredUser(getDashboardParams, function(err, data) {
                if (err) {
                    console.log(err, err.stack);
                    errorCallback(err);
                } else {
                    const result = {
                        "statusCode": 200,
                        "headers": {
                            "Access-Control-Allow-Origin": "*", // Use your website domain to secure access to GetEmbedUrl API
                            "Access-Control-Allow-Headers": "Content-Type"
                        },
                        "body": JSON.stringify(data),
                        "isBase64Encoded": false
                    }
                    getEmbedUrlCallback(result);
                }
            });
        }
    });
}
```

### Python3
<a name="embedded-analytics-full-console-for-authenticated-users-py"></a>

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

# Create QuickSight and STS clients
qs = boto3.client('quicksight', region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def generateEmbeddingURL(accountId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quickSightClient = assumedRoleSession.client('quicksight', region_name='us-east-1')
            
            experienceConfiguration = {
                "QuickSightConsole": {
                    "InitialPath": "/start"
                }
            }
            response = quickSightClient.generate_embed_url_for_registered_user(
                 AwsAccountId = accountId,
                 ExperienceConfiguration = experienceConfiguration,
                 UserArn = userArn,
                 AllowedDomains = allowedDomains,
                 SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-analytics-full-console-for-authenticated-users-node"></a>

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für die eingebettete Konsolensitzung zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Konsolensitzung aufzurufen. 

**Example**  

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

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

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': {
        'QuickSightConsole': {
            'InitialPath': '/start'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

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

### .NET/C\$1
<a name="embedded-analytics-full-console-for-authenticated-users-cs"></a>

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für die eingebettete Konsolensitzung generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Konsole aufzurufen. 

**Example**  

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

namespace GenerateDashboardEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserQuickSightConsoleEmbeddingConfiguration registeredUserQuickSightConsoleEmbeddingConfiguration
                    = new RegisteredUserQuickSightConsoleEmbeddingConfiguration
                    {
                        InitialPath = "/start"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        QuickSightConsole = registeredUserQuickSightConsoleEmbeddingConfiguration
                    };
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-analytics-full-console-for-authenticated-users-cli"></a>

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForRegisteredUser` aktiviert sein. Wenn Sie Benutzer hinzufügen möchten, just-in-time wenn diese Amazon Quick Sight zum ersten Mal öffnen, müssen für die Rolle auch die entsprechenden Berechtigungen aktiviert sein`quicksight:RegisterUser`.

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGRIFFSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_console_session_role/john.doe@example.com`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. Throttling ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. 

Die Rollensitzungs-ID wird auch zum Benutzernamen in Amazon Quick Sight. Sie können dieses Muster verwenden, um Ihre Benutzer vorab in Amazon Quick Sight bereitzustellen oder um sie beim ersten Zugriff auf eine Konsolensitzung bereitzustellen. 

Das folgende Beispiel zeigt den CLI-Befehl, den Sie verwenden können, um einen Benutzer bereitstellen. Weitere Informationen zu [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), und anderen Amazon Quick Sight API-Vorgängen finden Sie in der [Amazon Quick Sight API-Referenz](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html).

```
aws quicksight register-user \
     --aws-account-id 111122223333 \
     --namespace default \
     --identity-type IAM \
     --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
     --user-role READER \
     --user-name jhnd \
     --session-name "john.doe@example.com" \
     --email john.doe@example.com \
     --region us-east-1 \
     --custom-permissions-name TeamA1
```

Wenn der Benutzer durch Microsoft AD authentifiziert wird, müssen Sie `RegisterUser` nicht verwenden, um sie einzurichten. Stattdessen sollten sie automatisch abonniert werden, wenn sie zum ersten Mal auf Amazon Quick Sight zugreifen. Für Microsoft AD-Benutzer können Sie `DescribeUser` verwenden, um den Benutzer ARN zu erhalten.

Wenn ein Benutzer zum ersten Mal auf Amazon Quick Sight zugreift, können Sie diesen Benutzer auch der entsprechenden Gruppe hinzufügen. Das folgende Beispiel zeigt den CLI-Befehl zum Hinzufügen eines Benutzers zu einer Gruppe.

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

Sie haben jetzt einen Benutzer Ihrer App, der auch Amazon Quick Sight verwendet und Zugriff auf die Amazon Quick Sight-Konsolensitzung hat. 

Um eine signierte URL für die Konsolensitzung zu erhalten, rufen Sie schließlich `generate-embed-url-for-registered-user` vom App-Server auf. Dadurch wird die URL der einbettbaren Konsolensitzung zurückgegeben. Das folgende Beispiel zeigt, wie Sie die URL für eine eingebettete Konsolensitzung mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die über AWS Managed Microsoft AD oder Single Sign-On (IAM Identity Center) authentifiziert wurden.

```
aws quicksight generate-embed-url-for-registered-user \
    --aws-account-id 111122223333 \
    --entry-point the-url-for--the-console-session \
    --session-lifetime-in-minutes 600 \
    --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_dashboard_role/embeddingsession
	--allowed-domains '["domain1","domain2"]' \
    --experience-configuration QuickSightConsole={InitialPath="/start"}
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden. 

## Schritt 3: Betten Sie die URL der Konsolensitzung ein
<a name="embedded-analytics-full-console-for-authenticated-users-step-3"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die URL der Konsolensitzung aus Schritt 3 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie die Konsolensitzung auf einer HTML-Seite.
+ Übergeben Sie Parameter an die Konsolensitzung.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForRegisteredUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für bis zu 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code` bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-registered-user`:

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

Betten Sie diese Konsolensitzung mithilfe des Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) in Ihre Webseite ein oder fügen Sie diese URL zu einem Iframe hinzu. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter innerhalb der Konsolensitzung steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Die Domain, die eingebettete Dashboards hosten soll, muss auf der *Zulassungsliste stehen, der Liste* der zugelassenen Domains für Ihr Abonnement. Quick Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Dashboards zu hosten. Weitere Informationen zum Hinzufügen von Domains für eine eingebettete Konsole finden Sie unter [Zulassen, dass Domains zur Laufzeit mit der Amazon Quick Sight API](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) aufgelistet werden.

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

### SDK 2.0
<a name="embedded-analytics-full-console-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

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

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

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

                const contentOptions = {
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the embedded experience fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedConsoleExperience = await embeddingContext.embedConsole(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedSession()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-analytics-full-console-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Console Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.0.15/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

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

            function embedSession() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    // replace this dummy url with the one generated via embedding API
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    parameters: {
                        country: "United States"
                    },
                    scrolling: "no",
                    height: "700px",
                    width: "1000px",
                    locale: "en-US",
                    footerPaddingEnabled: true,
                    defaultEmbeddingVisualType: "TABLE", // this option only applies to QuickSight console embedding and is not used for dashboard embedding
                };
                session = QuickSightEmbedding.embedSession(options);
                session.on("error", onError);
            }

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

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

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um die eingebettete Konsolensitzung auf Ihrer Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

# Aktivieren der Features generativer BI in eingebetteten Konsolen für registrierte Benutzer
<a name="embedding-consoles-genbi"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Sie können die folgenden Features der generativen BI in Ihrer eingebetteten Konsole aktivieren:
+ Zusammenfassungen: Wenn diese Option aktiviert ist, können registrierte Author Pro- und Reader Pro-Benutzer Zusammenfassungen erstellen, die eine Zusammenfassung aller Erkenntnisse enthalten, die Amazon Quick Sight für das Dashboard generiert hat, um wichtige Erkenntnisse einfach zu ermitteln.
+ Erstellen: Wenn diese Option aktiviert ist, können Author Pro-Benutzer Generative BI verwenden, um berechnete Felder zu erstellen und Visualisierungen zu erstellen und zu verfeinern.
+ Fragen und Antworten: Wenn diese Option aktiviert ist, können Author Pro- und Reader Pro-Benutzer die KI-gestützten Fragen und Antworten verwenden, um Fragen zu ihren Daten sowohl vorzuschlagen als auch zu beantworten.
+ Datenstorys: Wenn diese Option aktiviert ist, können Author Pro- und Reader Pro-Benutzer Details angeben, um schnell einen ersten Entwurf ihrer Datenstory zu erstellen.

**So aktivieren Sie Features generativer BI in eingebetteten Konsolen für registrierte Benutzer**
+ Folgen Sie den Schritten unter [Einbetten der vollen Funktionalität der Amazon Quick Sight-Konsole für registrierte Benutzer](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-full-console-for-authenticated-users.html), um eine Konsole mit den folgenden Änderungen einzubetten:

  1. Wenn Sie die URL in Schritt 2 generieren, geben `Enabled: true` Sie den `FeatureConfigurations` Parameter für jede der Funktionen, die Sie aktivieren möchten, im [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)oder ein [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html) APIs, wie im folgenden Beispiel gezeigt. Wenn keine Konfiguration angegeben wird, sind die Features standardmäßig deaktiviert.

     ```
     ExperienceConfiguration: {
             QuickSightConsole: {
                 InitialPath: "initial_path",
                 AmazonQInQuickSight: {
                     FeatureConfigurations: { 
                         COMMENT: Enable executive summaries
                         ExecutiveSummary: {
                             Enabled: true
                         },
                         COMMENT: Enable Generative BI authoring
                         GenerativeAuthoring: {
                             Enabled: true
                         },
                         COMMENT: Enable Q&A
                         DataQnA: {
                             Enabled: true
                         },
                         COMMENT: Enable data stories
                         DataStories: {
                             Enabled: true
                         }       
                     }
                 }
             }
         }
     }
     ```

  1. Wenn Sie die Konsolen-URL mit dem Amazon Quick Sight Embedding SDK in Schritt 3 einbetten, legen Sie die Werte im folgenden Beispiel wie gewünscht fest. Wenn keine Konfiguration angegeben wird, sind die Features standardmäßig deaktiviert.
**Anmerkung**  
Es gibt keine SDK-Option zum Aktivieren von Datenstorys. Wenn Datenstorys wie im vorherigen Schritt gezeigt mit der API aktiviert werden, stehen sie registrierten Benutzern zur Verfügung.

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

# Einbetten von Amazon Q in Amazon Quick Sight Generatives Q&A-Erlebnis
<a name="embedding-gen-bi"></a>


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen darüber, wie Sie ein eingebettetes generatives Q&A-Erlebnis einrichten, das erweiterte NLQ-Funktionen nutzt, die von. LLMs Das Erlebnis mit generativem Q&A ist der empfohlene Ersatz für die eingebettete Q-Suchleiste und bietet Benutzern ein aktualisiertes BI-Erlebnis.

**Topics**
+ [

## Einbetten von Amazon Q in Amazon Quick Sight Generatives Q&A-Erlebnis für registrierte Benutzer
](#embedded-analytics-gen-bi-authenticated-users)
+ [

## Einbetten von Amazon Q in Quick Generative Q&A-Erfahrung für anonyme (nicht registrierte) Benutzer
](#embedded-analytics-gen-bi-anonymous-users)

## Einbetten von Amazon Q in Amazon Quick Sight Generatives Q&A-Erlebnis für registrierte Benutzer
<a name="embedded-analytics-gen-bi-authenticated-users"></a>

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung einer eingebetteten generativen Q&A-Erfahrung für registrierte Benutzer von Amazon Quick Sight.

**Topics**
+ [

### Schritt 1: Festlegen von Berechtigungen
](#embedded-analytics-gen-bi-authenticated-users-step-1)
+ [

### Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-analytics-gen-bi-authenticated-users-step-2)
+ [

### Schritt 3: Einbetten der URL des Erlebnisses mit generativem Q&A
](#embedded-analytics-gen-bi-authenticated-users-step-3)
+ [

### Optionale eingebettete Funktionen für das Erlebnis mit generativem Q&A
](#embedded-analytics-gen-bi-authenticated-users-step-4)

### Schritt 1: Festlegen von Berechtigungen
<a name="embedded-analytics-gen-bi-authenticated-users-step-1"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für Ihre Back-End-Anwendung oder Ihren Webserver einrichten, um das Erlebnis mit generativem Q&A einzubetten. Für diese Aufgabe ist Administratorzugriff auf AWS Identity and Access Management (IAM) erforderlich.

Jeder Benutzer, der auf ein generatives Q&A-Erlebnis zugreift, nimmt eine Rolle ein, die ihm Zugriff und Berechtigungen für Amazon Quick Sight gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem AWS-Konto. Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Die IAM-Rolle muss Berechtigungen zum Abrufen von Einbettungen URLs für einen bestimmten Benutzerpool bereitstellen. 

Mithilfe des Platzhalterzeichens *\$1* können Sie die Berechtigungen zum Generieren einer URL für alle Benutzer in einem bestimmten Namespace gewähren. Sie können auch Berechtigungen zum Generieren einer URL für eine Teilmenge von Benutzern in bestimmten Namespaces gewähren. Dazu fügen Sie `quicksight:GenerateEmbedUrlForRegisteredUser` hinzu.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForRegisteredUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es bietet Entwicklern die Möglichkeit, die statischen Domains, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind, zu überschreiben und stattdessen bis zu drei Domains oder Subdomänen aufzulisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die Website eines Entwicklers eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf das eingebettete Erlebnis mit generativem Q&A zugreifen. Ohne diese Bedingung können Entwickler jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen.

Wenn Sie Erstbenutzer erstellen, die Amazon Quick Sight-Leser sein werden, stellen Sie außerdem sicher, dass Sie die `quicksight:RegisterUser` Erlaubnis in der Richtlinie hinzufügen.

Die folgende Beispielrichtlinie gewährt Erstbenutzern, die Amazon Quick Sight-Leser sein sollen, die Erlaubnis, eine Einbettungs-URL abzurufen.

Der IAM-Identität Ihrer Anwendung muss schließlich eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Das heißt, wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle im Namen des Benutzers übernehmen und den Benutzer in Amazon Quick Sight bereitstellen. 

Das folgende Beispiel zeigt eine Vertrauensrichtlinie.

------
#### [ 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"
            }
        ]
    }
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien für die OpenId Connect- oder Security Assertion Markup Language (SAML)-Authentifizierung finden Sie in den folgenden Abschnitten im *IAM-Benutzerhandbuch: *
+ [Erstellen einer Rolle für Web-Identität oder OpenID-Connect-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Erstellen von Rollen für den SAML 2.0-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

### Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-analytics-gen-bi-authenticated-users-step-2"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Q-Themen-URL auf Ihrem Anwendungsserver abrufen. Wenn Sie planen, das Generative Q&A-Erlebnis für die Identitätstypen IAM oder Amazon Quick Sight einzubetten, teilen Sie den Benutzern das Q-Thema mit.

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Dann fügt die App den Benutzer zu Amazon Quick Sight hinzu, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Durch die Ausführung der beschriebenen Schritte wird sichergestellt, dass jeder Betrachter des Q-Themas in Amazon Quick Sight eindeutig bereitgestellt wird. Dazu werden benutzerspezifische Einstellungen erzwungen, etwa Sicherheit auf niedriger Ebene sowie dynamische Standardwerte für Parameter. Tag-basierte Sicherheit auf Zeilenebene kann für die Einbettung der Q-Leiste für anonyme Benutzer verwendet werden.

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Dieser Code wird auf Ihrem App-Server ausgeführt.

#### Java
<a name="embedded-analytics-gen-bi-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserGenerativeQnAEmbeddingConfiguration;

/**
 * Class to call QuickSight AWS SDK to get url for embedding Generative Q&A experience.
 */
public class RegisteredUserGenerativeQnAEmbeddingSample {

    private final AmazonQuickSight quickSightClient;

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

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

    public String getQuicksightEmbedUrl(
            final String accountId, // AWS Account ID
            final String topicId, // Topic ID to embed
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find how to get user arn for a QuickSight user.
            ) throws Exception {

        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withGenerativeQnA(new RegisteredUserGenerativeQnAEmbeddingConfiguration().withInitialTopicId(topicId));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

        return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
    }
}
```

#### JavaScript
<a name="embedded-analytics-gen-bi-authenticated-users-js"></a>

**Anmerkung**  
Die Generierung von eingebetteten URLs APIs kann nicht direkt von Browsern aus aufgerufen werden. Sehen Sie sich stattdessen das Beispiel Node.JS an.

#### Python3
<a name="embedded-analytics-gen-bi-authenticated-users-py"></a>

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

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# topicId: Topic ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, topicId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    'GenerativeQnA': {
                        'InitialTopicId': topicId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

#### Node.js
<a name="embedded-analytics-gen-bi-authenticated-users-node"></a>

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

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

var quicksightClient = new AWS.Service({
    region: 'us-east-1'
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'GenerativeQnA': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

#### .NET/C\$1
<a name="embedded-analytics-gen-bi-authenticated-users-cs"></a>

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für die eingebettete Q-Suchleiste zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Q-Suchleiste aufzurufen. 

**Example**  

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

namespace GenerateGenerativeQnAEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserGenerativeQnAEmbeddingConfiguration registeredUserGenerativeQnAEmbeddingConfiguration
                    = new RegisteredUserGenerativeQnAEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        GenerativeQnA = registeredUserGenerativeQnAEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

#### AWS CLI
<a name="embedded-analytics-gen-bi-authenticated-users-cli"></a>

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS) aus:
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForRegisteredUser` aktiviert sein. Wenn Sie Benutzer hinzufügen möchten, just-in-time wenn diese ein Thema in der Q-Suchleiste verwenden, müssen für die Rolle auch die entsprechenden Berechtigungen aktiviert sein. `quicksight:RegisterUser`

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGANGSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Für einen Microsoft Windows-Computer verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_q_search_bar_role/john.doe@example.com`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. *Throttling* ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. 

Die Rollensitzungs-ID wird auch zum Benutzernamen in Amazon Quick Sight. Sie können dieses Muster verwenden, um Ihre Benutzer in Amazon Quick Sight im Voraus bereitzustellen oder um sie beim ersten Zugriff auf das Generative Q&A-Erlebnis bereitzustellen. 

Das folgende Beispiel zeigt den CLI-Befehl, den Sie verwenden können, um einen Benutzer bereitstellen. Weitere Informationen zu [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), und anderen Amazon Quick Sight API-Vorgängen finden Sie in der [Amazon Quick Sight API-Referenz](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html).

```
aws quicksight register-user \
    --aws-account-id 111122223333 \
    --namespace default \
    --identity-type IAM\
    --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_q_generative_qna_role" \
    --user-role READER \
    --user-name jhnd \
    --session-name "john.doe@example.com" \
    --email john.doe@example.com \
    --region us-east-1 \
    --custom-permissions-name TeamA1
```

Wenn der Benutzer durch Microsoft AD authentifiziert wird, müssen Sie `RegisterUser` nicht verwenden, um sie einzurichten. Stattdessen sollten sie beim ersten Zugriff auf Amazon Quick Sight automatisch abonniert werden. Für Microsoft AD-Benutzer können Sie `DescribeUser` verwenden, um den Amazon-Ressourcennamen (ARN) des Benutzers zu erhalten.

Wenn ein Benutzer zum ersten Mal auf Amazon Quick Sight zugreift, können Sie diesen Benutzer auch zu der Gruppe hinzufügen, mit der das Dashboard geteilt wird. Das folgende Beispiel zeigt den CLI-Befehl zum Hinzufügen eines Benutzers zu einer Gruppe.

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

Sie haben jetzt einen Benutzer Ihrer App, der auch Amazon Quick Sight verwendet und Zugriff auf das Dashboard hat. 

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie schließlich `generate-embed-url-for-registered-user` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die über AWS Managed Microsoft AD oder Single Sign-On (IAM Identity Center) authentifiziert wurden.

```
aws quicksight generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId1","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'GenerativeQnA={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden.

### Schritt 3: Einbetten der URL des Erlebnisses mit generativem Q&A
<a name="embedded-analytics-gen-bi-authenticated-users-step-3"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie die URL für das Erlebnis mit generativem Q&A in Ihre Website oder Anwendungsseite einbetten können. Sie tun dies mit dem [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript). Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie das Erlebnis mit generativem Q&A auf einer HTML-Seite.
+ Passen Sie das Layout und das Erscheinungsbild des eingebetteten Erlebnisses an die Anforderungen Ihrer Anwendung an.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForRegisteredUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für bis zu 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code`-Wert bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-registered-user`:

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

Binden Sie das Generative Q&A-Erlebnis in Ihre Webseite ein, indem Sie das [Amazon Quick Sight-Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) verwenden oder diese URL zu einem Iframe hinzufügen. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. 

Vergewissern Sie sich, dass die Domain, auf der das eingebettete Generative Q&A-Erlebnis gehostet werden soll, auf der *Zulassungsliste* steht, der Liste der zugelassenen Domains für Ihr Amazon Quick Sight-Abonnement. Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Dashboards zu hosten. Weitere Informationen zum Hinzufügen von Domains für ein eingebettetes Erlebnis mit generativem Q&A finden Sie unter [Domains verwalten](manage-domains.md).

Sie können das Amazon Quick Sight Embedding SDK verwenden, um das Layout und das Erscheinungsbild des eingebetteten Generative Q&A-Erlebnisses an Ihre Anwendung anzupassen. Verwenden Sie die Eigenschaft `panelType`, um den Startstatus des Erlebnisses mit generativem Q&A zu konfigurieren, wenn es in Ihrer Anwendung gerendert wird. Stellen Sie die Eigenschaft `panelType` auf `'FULL'` ein, um das gesamte Fenster für das Erlebnis mit generativem Q&A zu rendern. Dieses Panel ähnelt der Erfahrung, die Amazon Quick Sight-Benutzer in der Amazon Quick Sight-Konsole haben. Die Rahmenhöhe des Fensters wird aufgrund der Benutzerinteraktion nicht geändert und entspricht dem Wert, den Sie in der Eigenschaft `frameOptions.height` festgelegt haben. Die Abbildung unten zeigt das Fenster für das Erlebnis mit generativem Q&A, das gerendert wird, wenn Sie den Wert `panelType` auf `'FULL'` setzen.

Stellen Sie die Eigenschaft `panelType` auf `'SEARCH_BAR'` ein, um das gesamte Fenster für das Erlebnis mit generativem Q&A als Suchleiste zu rendern. Diese Suchleiste ähnelt der Art und Weise, wie die Q-Suchleiste gerendert wird, wenn sie in eine Anwendung eingebettet ist. Die Suchleiste mit generativem Q&A wird zu einem größeren Bereich erweitert, in dem Optionen zur Themenauswahl, die Liste mit Fragenvorschlägen, das Antwortfeld oder die Pinnwand angezeigt werden.

Die standardmäßige Mindesthöhe der Suchleiste mit generativem Q&A wird gerendert, wenn die eingebettete Ressource geladen wird. Es wird empfohlen, den Wert `frameOptions.height` auf `"38px"` festzulegen, um das Erlebnis der Suchleiste zu optimieren. Verwenden Sie die Eigenschaft `focusedHeight`, um die optimale Größe der Dropdownliste für die Themenauswahl und die Liste mit den Fragenvorschlägen festzulegen. Verwenden Sie die Eigenschaft `expandedHeight`, um die optimale Größe des Antwortfensters und der Pinnwand festzulegen. Wenn Sie die Option `'SEARCH_BAR'` wählen, wird empfohlen, den übergeordneten Container mit position; absolute zu formatieren, um unerwünschte Inhaltsverschiebungen in Ihrer Anwendung zu vermeiden. Die Abbildung unten zeigt die Suchleiste für das Erlebnis mit generativem Q&A, die gerendert wird, wenn Sie den Wert `panelType` auf `'SEARCH_BAR'` setzen.

Nachdem Sie die `panelType` Eigenschaft konfiguriert haben, verwenden Sie das Amazon Quick Sight Embedding SDK, um die folgenden Eigenschaften der Generative Q&A-Erfahrung anzupassen.
+ Der Titel des Bereichs für generatives Q&A (gilt nur für die Option `panelType: FULL`). 
+ Der Platzhaltertext der Suchleiste.
+ Ob die Themenauswahl zulässig ist.
+ Ob Themennamen ein- oder ausgeblendet werden.
+ Ob das Amazon Q-Symbol ein- oder ausgeblendet wird (gilt nur für die Option `panelType: FULL`).
+ Ob die Pinnwand ein- oder ausgeblendet wird.
+ Ob Benutzer den Bereich für generatives Q&A auf den Vollbildmodus maximieren können.
+ Das Design des Bereichs für generatives Q&A. Ein benutzerdefinierter Design-ARN kann im SDK übergeben werden, um das Erscheinungsbild des Frame-Inhalts zu ändern. Amazon Quick Sight-Starter-Themen werden für eingebettete Generative BI-Panels nicht unterstützt. Um ein Amazon Quick Sight-Starter-Theme zu verwenden, speichern Sie es als benutzerdefiniertes Design in Amazon Quick Sight.

Wenn Sie das Amazon Quick Sight Embedding SDK verwenden, wird die Größe des Generativen Q&A-Erlebnisses auf Ihrer Seite je nach Status dynamisch angepasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter innerhalb der Generative Q&A-Oberfläche steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs, Statusänderungen und Fehler erhalten. 

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

#### SDK 2.0
<a name="collapsible-gen-bi-embedding-example"></a>

```
<!DOCTYPE html>
<html>
    <head>
        <title>Generative Q&A Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.7.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedGenerativeQnA = async() => {    
                const {createEmbeddingContext} = QuickSightEmbedding;

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

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

                const contentOptions = {
                    // Optional panel settings. Default behavior is equivalent to {panelType: 'FULL'}
                    panelOptions: {
                        panelType: 'FULL',
                        title: 'custom title', // Optional
                        showQIcon: false, // Optional, Default: true
                    },
                    // Use SEARCH_BAR panel type for the landing state to be similar to embedQSearchBar
                    // with generative capability enabled topics
                    /*
                    panelOptions: {
                        panelType: 'SEARCH_BAR',
                        focusedHeight: '250px',
                        expandedHeight: '500px',
                    },
                    */
                    showTopicName: false, // Optional, Default: true
                    showPinboard: false, // Optional, Default: true
                    allowTopicSelection: false, // Optional, Default: true
                    allowFullscreen: false, // Optional, Default: true
                    searchPlaceholderText: "custom search placeholder", // Optional
                    themeOptions: { // Optional
                        themeArn: 'arn:aws:quicksight:<Region>:<AWS-Account-ID>:theme/<Theme-ID>'
                    }
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                // called when pinboard is shown / visuals are rendered
                                console.log("Do something when SEARCH_BAR type panel is expanded");
                                break;
                            }
                            case 'Q_SEARCH_FOCUSED': {
                                // called when question suggestions or topic selection dropdown are shown
                                console.log("Do something when SEARCH_BAR type panel is focused");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                // called when shrinked to initial bar height
                                console.log("Do something when SEARCH_BAR type panel is collapsed");
                                break;
                            }
                            case 'Q_PANEL_ENTERED_FULLSCREEN': {
                                console.log("Do something when panel enters full screen mode");
                                break;
                            }
                            case 'Q_PANEL_EXITED_FULLSCREEN': {
                                console.log("Do something when panel exits full screen mode");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something after experience is loaded");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when experience fails to load");
                                break;
                            }
                        }
                    }
                };
                const embeddedGenerativeQnExperience = await embeddingContext.embedGenerativeQnA(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedGenerativeQnA()">
        <div id="experience-container"></div>
    </body>

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Generative Q&A-Erlebnis auf Ihre Website zu laden. JavaScript Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

### Optionale eingebettete Funktionen für das Erlebnis mit generativem Q&A
<a name="embedded-analytics-gen-bi-authenticated-users-step-4"></a>

Die folgenden optionalen Funktionen sind für das eingebettete Erlebnis mit generativem Q&A mithilfe des Embedding SDK verfügbar. 

#### Suchleistenaktionen mit generativem Q&A aufrufen
<a name="w2aac35c27c21c43c29b9c21b5"></a>
+ Eine Frage stellen – Dieses Feature sendet eine Frage an das Erlebnis mit generativem Q&A und fragt die Frage umgehend ab.

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ Den Antwortbereich schließen (gilt für die Suchleistenoption mit generativem Q&A) – Dieses Feature schließt den Antwortbereich und setzt den iframe in den ursprünglichen Zustand der Suchleiste zurück.

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

Weitere Informationen finden Sie im [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

## Einbetten von Amazon Q in Quick Generative Q&A-Erfahrung für anonyme (nicht registrierte) Benutzer
<a name="embedded-analytics-gen-bi-anonymous-users"></a>


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen zum Einrichten eines eingebetteten Erlebnisses mit generativem Q&A für anonyme (nicht registrierte) Benutzer.

**Topics**
+ [

### Schritt 1: Festlegen von Berechtigungen
](#embedded-analytics-gen-bi-anonymous-users-step-1)
+ [

### Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-analytics-gen-bi-anonymous-users-step-2)
+ [

### Schritt 3: Einbetten der URL des Erlebnisses mit generativem Q&A
](#embedded-analytics-gen-bi-anonymous-users-step-3)
+ [

### Optionale eingebettete Funktionen für das Erlebnis mit generativem Q&A
](#embedded-analytics-gen-bi-anonymous-users-step-4)

### Schritt 1: Festlegen von Berechtigungen
<a name="embedded-analytics-gen-bi-anonymous-users-step-1"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für Ihre Back-End-Anwendung oder Ihren Webserver einrichten, um das Erlebnis mit generativem Q&A einzubetten. Für diese Aufgabe ist Administratorzugriff auf AWS Identity and Access Management (IAM) erforderlich.

Jeder Benutzer, der auf ein generatives Q&A-Erlebnis zugreift, nimmt eine Rolle ein, die ihm Zugriff und Berechtigungen für Amazon Quick Sight gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem AWS-Konto. Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Die IAM-Rolle muss Berechtigungen zum Abrufen von Einbettungen URLs für einen bestimmten Benutzerpool bereitstellen. 

Mithilfe des Platzhalterzeichens *\$1* können Sie die Berechtigungen zum Generieren einer URL für alle Benutzer in einem bestimmten Namespace gewähren. Sie können auch Berechtigungen zum Generieren einer URL für eine Teilmenge von Benutzern in bestimmten Namespaces gewähren. Dazu fügen Sie `quicksight:GenerateEmbedUrlForAnonymousUser` hinzu.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForAnonymousUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es bietet Entwicklern die Möglichkeit, die statischen Domains, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind, zu überschreiben und stattdessen bis zu drei Domains oder Subdomänen aufzulisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die Website eines Entwicklers eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf die eingebettete Q-Suchleiste zugreifen. Ohne diese Bedingung können Entwickler jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Der IAM-Identität Ihrer Anwendung muss eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Dies bedeutet: Wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle für den Benutzer übernehmen, um das Erlebnis mit generativem Q&A zu laden. Das folgende Beispiel zeigt eine Vertrauensrichtlinie.

------
#### [ 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"
        }
    ]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien finden Sie unter [Temporäre Sicherheitsanmeldeinformationen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*.

### Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-analytics-gen-bi-anonymous-users-step-2"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Q-Themen-URL auf Ihrem Anwendungsserver abrufen.

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Dann fügt die App den Benutzer zu Amazon Quick Sight hinzu, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

#### Java
<a name="embedded-analytics-gen-bi-anonymous-users-java"></a>

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

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

    private final AmazonQuickSight quickSightClient;

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

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

    public String GenerateEmbedUrlForAnonymousUser(
        final String accountId, // YOUR AWS ACCOUNT ID
        final String initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS AND EXPERIENCE PREPOPULATES INITIALLY
        final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
        final List<String> authorizedResourceArns, // Q TOPIC ARN LIST TO EMBED
        final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
        final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
    ) throws Exception {
        AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
        AnonymousUserGenerativeQnAEmbeddingConfiguration generativeQnAConfiguration = new AnonymousUserGenerativeQnAEmbeddingConfiguration();
        generativeQnAConfiguration.setInitialTopicId(initialTopicId);
        experienceConfiguration.setGenerativeQnA(generativeQnAConfiguration);

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

        GenerateEmbedUrlForAnonymousUserResult result = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

        return result.getEmbedUrl();
    }

}
```

#### JavaScript
<a name="embedded-analytics-gen-bi-anonymous-users-js"></a>

**Anmerkung**  
Die Generierung von eingebetteten URLs APIs kann nicht direkt von Browsern aus aufgerufen werden. Sehen Sie sich stattdessen das Beispiel Node.JS an.

#### Python3
<a name="embedded-analytics-gen-bi-anonymous-users-py"></a>

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

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

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

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

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

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

var quicksightClient = new AWS.Service({
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace': 'DEFAULT'
    'AuthorizedResourceArns': '["topic-arn-topicId1","topic-arn-topicId2"]',
    'AllowedDomains': allowedDomains,
    'ExperienceConfiguration': { 
        'GenerativeQnA': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'SessionTags': '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
    'SessionLifetimeInMinutes': 15
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

#### .NET/C\$1
<a name="embedded-analytics-gen-bi-anonymous-users-cs"></a>

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für die eingebettete Q-Suchleiste zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Q-Suchleiste aufzurufen. 

**Example**  

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

namespace GenerateGenerativeQnAEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                AnonymousUserGenerativeQnAEmbeddingConfiguration anonymousUserGenerativeQnAEmbeddingConfiguration
                    = new AnonymousUserGenerativeQnAEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        GenerativeQnA = anonymousUserGenerativeQnAEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111122223333",
                        Namespace = "DEFAULT",
                        AuthorizedResourceArns '["topic-arn-topicId1","topic-arn-topicId2"]',
                        AllowedDomains = allowedDomains,
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
                        SessionLifetimeInMinutes = 15,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

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

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS) aus:
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForAnonymousUser` aktiviert sein.

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGANGSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Für einen Microsoft Windows-Computer verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_q_search_bar_role/QuickSightEmbeddingAnonymousPolicy`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. *Throttling* ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. Darüber hinaus hält sie auch jede Sitzung getrennt und unterscheidbar. Wenn Sie eine Reihe von Webservern verwenden, z. B. für den Lastenausgleich, und eine Sitzung erneut mit einem anderen Server verbunden wird, beginnt eine neue Sitzung.

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie `generate-embed-url-for-anynymous-user` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die Ihr Webportal oder Ihre App anonym besuchen.

```
aws quicksight generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'GenerativeQnA={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden.

### Schritt 3: Einbetten der URL des Erlebnisses mit generativem Q&A
<a name="embedded-analytics-gen-bi-anonymous-users-step-3"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie die URL für das Erlebnis mit generativem Q&A in Ihre Website oder Anwendungsseite einbetten können. Sie tun dies mit dem [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript). Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie das Erlebnis mit generativem Q&A auf einer HTML-Seite.
+ Passen Sie das Layout und das Erscheinungsbild des eingebetteten Erlebnisses an die Anforderungen Ihrer Anwendung an.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForAnonymousUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für bis zu 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code`-Wert bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-anonymous-user`:

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

Binden Sie das Generative Q&A-Erlebnis mit dem [Amazon Quick Sight-Embedding-SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) oder durch Hinzufügen dieser URL in einen Iframe in Ihre Webseite ein. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. 

Vergewissern Sie sich, dass die Domain, auf der das Generative Q&A-Erlebnis gehostet werden soll, auf der *Zulassungsliste* steht, der Liste der zugelassenen Domains für Ihr Amazon Quick Sight-Abonnement. Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Erlebnisse mit generativem Q&A zu hosten. Weitere Informationen zum Hinzufügen von Domains für ein eingebettetes Erlebnis mit generativem Q&A finden Sie unter [Domains verwalten](manage-domains.md).

Sie können das Amazon Quick Sight Embedding SDK verwenden, um das Layout und das Erscheinungsbild des eingebetteten Generative Q&A-Erlebnisses an Ihre Anwendung anzupassen. Verwenden Sie die Eigenschaft `panelType`, um den Startstatus des Erlebnisses mit generativem Q&A zu konfigurieren, wenn es in Ihrer Anwendung gerendert wird. Stellen Sie die Eigenschaft `panelType` auf `'FULL'` ein, um das gesamte Fenster für das Erlebnis mit generativem Q&A zu rendern. Dieses Panel ähnelt der Erfahrung, die Amazon Quick Sight-Benutzer in der Amazon Quick Sight-Konsole haben. Die Rahmenhöhe des Fensters wird aufgrund der Benutzerinteraktion nicht geändert und entspricht dem Wert, den Sie in der Eigenschaft `frameOptions.height` festgelegt haben. Die Abbildung unten zeigt das Fenster für das Erlebnis mit generativem Q&A, das gerendert wird, wenn Sie den Wert `panelType` auf `'FULL'` setzen.

Stellen Sie die Eigenschaft `panelType` auf `'SEARCH_BAR'` ein, um das gesamte Fenster für das Erlebnis mit generativem Q&A als Suchleiste zu rendern. Diese Suchleiste ähnelt der Art und Weise, wie die Q-Suchleiste gerendert wird, wenn sie in eine Anwendung eingebettet ist. Die Suchleiste mit generativem Q&A wird zu einem größeren Bereich erweitert, in dem Optionen zur Themenauswahl, die Liste mit Fragenvorschlägen, das Antwortfeld oder die Pinnwand angezeigt werden.

Die standardmäßige Mindesthöhe der Suchleiste mit generativem Q&A wird gerendert, wenn die eingebettete Ressource geladen wird. Es wird empfohlen, den Wert `frameOptions.height` auf `"38px"` festzulegen, um das Erlebnis der Suchleiste zu optimieren. Verwenden Sie die Eigenschaft `focusedHeight`, um die optimale Größe der Dropdownliste für die Themenauswahl und die Liste mit den Fragenvorschlägen festzulegen. Verwenden Sie die Eigenschaft `expandedHeight`, um die optimale Größe des Antwortfensters und der Pinnwand festzulegen. Wenn Sie die Option `'SEARCH_BAR'` wählen, wird empfohlen, den übergeordneten Container mit position; absolute zu formatieren, um unerwünschte Inhaltsverschiebungen in Ihrer Anwendung zu vermeiden. Die Abbildung unten zeigt die Suchleiste für das Erlebnis mit generativem Q&A, die gerendert wird, wenn Sie den Wert `panelType` auf `'SEARCH_BAR'` setzen.

Nachdem Sie die `panelType` Eigenschaft konfiguriert haben, verwenden Sie das Amazon Quick Sight Embedding SDK, um die folgenden Eigenschaften der Generative Q&A-Erfahrung anzupassen.
+ Der Titel des Bereichs für generatives Q&A (gilt nur für die Option `panelType: FULL`). 
+ Der Platzhaltertext der Suchleiste.
+ Ob die Themenauswahl zulässig ist.
+ Ob Themennamen ein- oder ausgeblendet werden.
+ Ob das Amazon Q-Symbol ein- oder ausgeblendet wird (gilt nur für die Option `panelType: FULL`).
+ Ob die Pinnwand ein- oder ausgeblendet wird.
+ Ob Benutzer den Bereich für generatives Q&A auf den Vollbildmodus maximieren können.
+ Das Design des Bereichs für generatives Q&A. Ein benutzerdefinierter Design-ARN kann im SDK übergeben werden, um das Erscheinungsbild des Frame-Inhalts zu ändern. Amazon Quick Sight-Starter-Themen werden für eingebettete Generative BI-Panels nicht unterstützt. Um ein Amazon Quick Sight-Starter-Theme zu verwenden, speichern Sie es als benutzerdefiniertes Design in Amazon Quick Sight.

Wenn Sie das Amazon Quick Sight Embedding SDK verwenden, wird die Größe des Generativen Q&A-Erlebnisses auf Ihrer Seite je nach Status dynamisch angepasst. Mit dem Amazon Quick Sight Embedding SDK können Sie auch Parameter innerhalb der Generative Q&A-Erfahrung steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs, Statusänderungen und Fehler erhalten. 

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

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

```
<!DOCTYPE html>
<html>
    <head>
        <title>Generative Q&A Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.7.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedGenerativeQnA = async() => {    
                const {createEmbeddingContext} = QuickSightEmbedding;

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

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

                const contentOptions = {
                    // Optional panel settings. Default behavior is equivalent to {panelType: 'FULL'}
                    panelOptions: {
                        panelType: 'FULL',
                        title: 'custom title', // Optional
                        showQIcon: false, // Optional, Default: true
                    },
                    // Use SEARCH_BAR panel type for the landing state to be similar to embedQSearchBar
                    // with generative capability enabled topics
                    /*
                    panelOptions: {
                        panelType: 'SEARCH_BAR',
                        focusedHeight: '250px',
                        expandedHeight: '500px',
                    },
                    */
                    showTopicName: false, // Optional, Default: true
                    showPinboard: false, // Optional, Default: true
                    allowTopicSelection: false, // Optional, Default: true
                    allowFullscreen: false, // Optional, Default: true
                    searchPlaceholderText: "custom search placeholder", // Optional
                    themeOptions: { // Optional
                        themeArn: 'arn:aws:quicksight:<Region>:<AWS-Account-ID>:theme/<Theme-ID>'
                    }
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                // called when pinboard is shown / visuals are rendered
                                console.log("Do something when SEARCH_BAR type panel is expanded");
                                break;
                            }
                            case 'Q_SEARCH_FOCUSED': {
                                // called when question suggestions or topic selection dropdown are shown
                                console.log("Do something when SEARCH_BAR type panel is focused");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                // called when shrinked to initial bar height
                                console.log("Do something when SEARCH_BAR type panel is collapsed");
                                break;
                            }
                            case 'Q_PANEL_ENTERED_FULLSCREEN': {
                                console.log("Do something when panel enters full screen mode");
                                break;
                            }
                            case 'Q_PANEL_EXITED_FULLSCREEN': {
                                console.log("Do something when panel exits full screen mode");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something after experience is loaded");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when experience fails to load");
                                break;
                            }
                        }
                    }
                };
                const embeddedGenerativeQnExperience = await embeddingContext.embedGenerativeQnA(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedGenerativeQnA()">
        <div id="experience-container"></div>
    </body>

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Generative Q&A-Erlebnis auf Ihre Website zu laden. JavaScript Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

### Optionale eingebettete Funktionen für das Erlebnis mit generativem Q&A
<a name="embedded-analytics-gen-bi-anonymous-users-step-4"></a>

Die folgenden optionalen Funktionen sind für das eingebettete Erlebnis mit generativem Q&A mithilfe des Embedding SDK verfügbar. 

#### Suchleistenaktionen mit generativem Q&A aufrufen
<a name="w2aac35c27c21c43c29c13c25b5"></a>
+ Eine Frage stellen – Dieses Feature sendet eine Frage an das Erlebnis mit generativem Q&A und fragt die Frage umgehend ab.

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ Den Antwortbereich schließen (gilt für die Suchleistenoption mit generativem Q&A) – Dieses Feature schließt den Antwortbereich und setzt den iframe in den ursprünglichen Zustand der Suchleiste zurück.

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

Weitere Informationen finden Sie im [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Einbetten der Amazon Quick Sight Q-Suchleiste (Classic)
<a name="embedding-quicksight-q"></a>


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

In den folgenden Themen erfahren Sie, wie Sie die Amazon Quick Sight Q-Suchleiste in Amazon Quick Sight APIs einbetten.

**Topics**
+ [

# Einbetten der Amazon Quick Sight Q-Suchleiste für registrierte Benutzer
](embedded-analytics-q-search-bar-for-authenticated-users.md)
+ [

# Einbetten der Amazon Quick Sight Q-Suchleiste für anonyme (nicht registrierte) Benutzer
](embedded-analytics-q-search-bar-for-anonymous-users.md)

# Einbetten der Amazon Quick Sight Q-Suchleiste für registrierte Benutzer
<a name="embedded-analytics-q-search-bar-for-authenticated-users"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung einer eingebetteten Amazon Quick Sight Q-Suchleiste für registrierte Benutzer von Amazon Quick Sight.

**Topics**
+ [

## Schritt 1: Festlegen von Berechtigungen
](#embedded-q-bar-for-authenticated-users-step-1)
+ [

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-q-bar-for-authenticated-users-step-2)
+ [

## Schritt 3: Betten Sie die URL der Q-Suchleiste ein
](#embedded-q-bar-for-authenticated-users-step-3)
+ [

## Optionale Funktionen zum Einbetten der Suchleiste von Amazon Quick Sight Q
](#embedded-q-bar-for-authenticated-users-step-4)

## Schritt 1: Festlegen von Berechtigungen
<a name="embedded-q-bar-for-authenticated-users-step-1"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für Ihre Back-End-Anwendung oder Ihren Webserver einrichten, um die Q-Suchleiste einzubetten. Für diese Aufgabe ist Administratorzugriff auf AWS Identity and Access Management (IAM) erforderlich.

Jeder Benutzer, der auf ein Dashboard zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für das Dashboard gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem. AWS-Konto Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Die IAM-Rolle muss Berechtigungen zum Abrufen von Einbettungen URLs für einen bestimmten Benutzerpool bereitstellen. 

Mithilfe des Platzhalterzeichens *\$1* können Sie die Berechtigungen zum Generieren einer URL für alle Benutzer in einem bestimmten Namespace gewähren. Sie können auch Berechtigungen zum Generieren einer URL für eine Teilmenge von Benutzern in bestimmten Namespaces gewähren. Dazu fügen Sie `quicksight:GenerateEmbedUrlForRegisteredUser` hinzu.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForRegisteredUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es gibt Entwicklern die Möglichkeit, die statischen Domains, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind, zu überschreiben und stattdessen bis zu drei Domains oder Subdomains aufzulisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die Website eines Entwicklers eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf die eingebettete Q-Suchleiste zugreifen. Ohne diese Bedingung können Entwickler jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen.

Wenn Sie Erstbenutzer erstellen, die Amazon Quick Sight-Leser sein werden, stellen Sie außerdem sicher, dass Sie die `quicksight:RegisterUser` Erlaubnis in der Richtlinie hinzufügen.

Die folgende Beispielrichtlinie gewährt Erstbenutzern, die Amazon Quick Sight-Leser sein sollen, die Erlaubnis, eine Einbettungs-URL abzurufen.

Der IAM-Identität Ihrer Anwendung muss schließlich eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Das heißt, wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle im Namen des Benutzers übernehmen und den Benutzer in Amazon Quick Sight bereitstellen. 

Das folgende Beispiel zeigt eine Vertrauensrichtlinie.

------
#### [ 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"
        }
    ]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien für die OpenId Connect- oder Security Assertion Markup Language (SAML)-Authentifizierung finden Sie in den folgenden Abschnitten im *IAM-Benutzerhandbuch: *
+ [Erstellen einer Rolle für Web-Identität oder OpenID-Connect-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Erstellen von Rollen für den SAML 2.0-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-q-bar-for-authenticated-users-step-2"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Q-Themen-URL auf Ihrem Anwendungsserver abrufen. Wenn Sie die Q-Leiste für IAM- oder Amazon Quick Sight-Identitätstypen einbetten möchten, teilen Sie das Q-Thema den Benutzern mit.

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Dann fügt die App den Benutzer zu Amazon Quick Sight hinzu, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Durch die Ausführung der beschriebenen Schritte wird sichergestellt, dass jeder Betrachter des Q-Themas in Amazon Quick Sight eindeutig bereitgestellt wird. Dazu werden benutzerspezifische Einstellungen erzwungen, etwa Sicherheit auf niedriger Ebene sowie dynamische Standardwerte für Parameter.

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Dieser Code wird auf Ihrem App-Server ausgeführt.

### Java
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
        import com.amazonaws.auth.AWSCredentialsProvider;
        import com.amazonaws.regions.Regions;
        import com.amazonaws.services.quicksight.AmazonQuickSight;
        import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserQSearchBarEmbeddingConfiguration;

        /**
 * Class to call QuickSight AWS SDK to get url for embedding the Q search bar.
        */
public class RegisteredUserQSearchBarEmbeddingConfiguration {

            private final AmazonQuickSight quickSightClient;

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

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

    public String getQuicksightEmbedUrl(
            final String accountId, // AWS Account ID
            final String topicId, // Topic ID to embed
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find how to get user arn for a QuickSight user.
            ) throws Exception {
        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withQSearchBar(new RegisteredUserQSearchBarEmbeddingConfiguration().withInitialTopicId(topicId));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(QSearchBar);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

        return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
            }
        }
```

### JavaScript
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-js"></a>

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

function generateEmbedUrlForRegisteredUser(
    accountId,
    topicId, // Topic ID to embed
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    getEmbedUrlCallback, // GetEmbedUrl success callback method
    errorCallback // GetEmbedUrl error callback method
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
        }
    
    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getQSearchBarParams = {
        "AwsAccountId": accountId,
                "ExperienceConfiguration": {
                    "QSearchBar": {
                        "InitialTopicId": topicId
                    }
                },
                "UserArn": userArn,
        "AllowedDomains": allowedDomains,
        "SessionLifetimeInMinutes": 600
    };

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

            quicksightGetQSearchBar.generateEmbedUrlForRegisteredUser(getQSearchBarParams, function(err, data) {
        if (err) {
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const result = {
                "statusCode": 200,
                "headers": {
                            "Access-Control-Allow-Origin": "*", // Use your website domain to secure access to GetEmbedUrl API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
                    getEmbedUrlCallback(result);
                }
            });
        }
    });
}
```

### Python3
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-python"></a>

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

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# topicId: Topic ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, topicId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    "QSearchBar": {
                        "InitialTopicId": topicId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-node"></a>

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

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

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

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'QSearchBar': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

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

### .NET/C\$1
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-cs"></a>

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für die eingebettete Q-Suchleiste zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Q-Suchleiste aufzurufen. 

**Example**  

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

namespace GenerateDashboardEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserQSearchBarEmbeddingConfiguration registeredUserQSearchBarEmbeddingConfiguration
                    = new RegisteredUserQSearchBarEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        QSearchBar = registeredUserQSearchBarEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-cli"></a>

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForRegisteredUser` aktiviert sein. Wenn Sie Benutzer hinzufügen möchten, just-in-time wenn diese ein Thema in der Q-Suchleiste verwenden, müssen für die Rolle auch die entsprechenden Berechtigungen aktiviert sein. `quicksight:RegisterUser`

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGANGSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Für einen Microsoft Windows-Computer verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_q_search_bar_role/john.doe@example.com`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. *Throttling* ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. 

Die Rollensitzungs-ID wird auch zum Benutzernamen in Amazon Quick Sight. Sie können dieses Muster verwenden, um Ihre Benutzer in Amazon Quick Sight im Voraus bereitzustellen oder um sie beim ersten Zugriff auf die Q-Suchleiste bereitzustellen. 

Das folgende Beispiel zeigt den CLI-Befehl, den Sie verwenden können, um einen Benutzer bereitstellen. Weitere Informationen zu [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), und anderen Amazon Quick Sight API-Vorgängen finden Sie in der [Amazon Quick Sight API-Referenz](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html).

```
aws quicksight register-user \
    --aws-account-id 111122223333 \
    --namespace default \
    --identity-type IAM \
    --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_q_search_bar_role" \
    --user-role READER \
    --user-name jhnd \
    --session-name "john.doe@example.com" \
    --email john.doe@example.com \
    --region us-east-1 \
    --custom-permissions-name TeamA1
```

Wenn der Benutzer durch Microsoft AD authentifiziert wird, müssen Sie `RegisterUser` nicht verwenden, um sie einzurichten. Stattdessen sollten sie beim ersten Zugriff auf Amazon Quick Sight automatisch abonniert werden. Für Microsoft AD-Benutzer können Sie `DescribeUser` verwenden, um den Amazon-Ressourcennamen (ARN) des Benutzers zu erhalten.

Wenn ein Benutzer zum ersten Mal auf Amazon Quick Sight zugreift, können Sie diesen Benutzer auch zu der Gruppe hinzufügen, mit der das Dashboard geteilt wird. Das folgende Beispiel zeigt den CLI-Befehl zum Hinzufügen eines Benutzers zu einer Gruppe.

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

Sie haben jetzt einen Benutzer Ihrer App, der auch Amazon Quick Sight verwendet und Zugriff auf das Dashboard hat. 

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie schließlich `generate-embed-url-for-registered-user` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die über AWS Managed Microsoft AD oder Single Sign-On (IAM Identity Center) authentifiziert wurden.

```
aws quicksight generate-embed-url-for-registered-user \
--aws-account-id 111122223333 \
--session-lifetime-in-minutes 600 \
--user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_q_search_bar_role/embeddingsession
--allowed-domains '["domain1","domain2"]' \
--experience-configuration QSearchBar={InitialTopicId=U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f}
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden.

## Schritt 3: Betten Sie die URL der Q-Suchleiste ein
<a name="embedded-q-bar-for-authenticated-users-step-3"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Im folgenden Abschnitt erfahren Sie, wie Sie die Q-Suchleisten-URL aus Schritt 3 in Ihre Website oder Anwendungsseite einbetten. Sie tun dies mit dem [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript). Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie die Q-Suchleiste auf einer HTML-Seite.
+ Übergeben Sie Parameter an die Q-Suchleiste.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForRegisteredUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für bis zu 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code`-Wert bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-registered-user`:

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

Betten Sie die Q-Suchleiste in Ihre Webseite ein, indem Sie das [Amazon Quick Sight-Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) verwenden oder diese URL zu einem Iframe hinzufügen. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. 

Stellen Sie dazu sicher, dass die Domain, die die eingebettete Q-Suchleiste hosten soll, auf der *Zulassungsliste* steht, der Liste der zugelassenen Domains für Ihr Amazon Quick Sight-Abonnement. Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Dashboards zu hosten. Weitere Informationen zum Hinzufügen von Domains für eine eingebettete Q-Suchleiste finden Sie unter [Domains verwalten und einbetten](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html).

Wenn Sie das Amazon Quick Sight Embedding SDK verwenden, wird die Größe der Q-Suchleiste auf Ihrer Seite je nach Status dynamisch angepasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter in der Q-Suchleiste steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

### SDK 2.0
<a name="embedded-q-bar-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

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

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

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

                const contentOptions = {
                    hideTopicName: false, 
                    theme: '<YOUR_THEME_ID>',
                    allowTopicSelection: true,
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                console.log("Do something when Q Search content expanded");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                console.log("Do something when Q Search content collapsed");
                                break;
                            }
                            case 'Q_SEARCH_SIZE_CHANGED': {
                                console.log("Do something when Q Search size changed");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something when the Q Search is loaded.");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the Q Search fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedDashboardExperience = await embeddingContext.embedQSearchBar(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-q-bar-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Q Search Bar Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.18.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

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

            function onOpen() {
                console.log("Do something when the Q search bar opens");
            }

            function onClose() {
                console.log("Do something when the Q search bar closes");
            }

            function embedQSearchBar() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    width: "1000px",
                    locale: "en-US",
                    qSearchBarOptions: {
                        expandCallback: onOpen,
                        collapseCallback: onClose,
                        iconDisabled: false,
                        topicNameDisabled: false, 
                        themeId: 'bdb844d0-0fe9-4d9d-b520-0fe602d93639',
                        allowTopicSelection: true
                    }
                };
                session = QuickSightEmbedding.embedQSearchBar(options);
                session.on("error", onError);
            }

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

    <body onload="embedQSearchBar()">
        <div id="embeddingContainer"></div>
    </body>

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Dashboard auf Ihre Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

## Optionale Funktionen zum Einbetten der Suchleiste von Amazon Quick Sight Q
<a name="embedded-q-bar-for-authenticated-users-step-4"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Die folgenden optionalen Funktionen sind für die eingebettete Q-Suchleiste mithilfe des eingebetteten SDK verfügbar. 

### Rufen Sie Aktionen in der Q-Suchleiste auf
<a name="w2aac35c27c21c43c31c15c21b7"></a>

Die folgenden Optionen werden nur für die Einbettung von Q-Suchleisten unterstützt. 
+ Stellen Sie ein Feature in der Q-Suchleiste ein — Dieses Feature sendet eine Frage an die Q-Suchleiste und fragt die Abfrage sofort ab. Außerdem wird das Q-Popover automatisch geöffnet.

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Q-Popover schließen — Dieses Feature schließt das Q-Popover und setzt den iframe auf die ursprüngliche Größe der Q-Suchleiste zurück.

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

Weitere Informationen finden Sie im [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Einbetten der Amazon Quick Sight Q-Suchleiste für anonyme (nicht registrierte) Benutzer
<a name="embedded-analytics-q-search-bar-for-anonymous-users"></a>


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

In den folgenden Abschnitten finden Sie detaillierte Informationen zum Einrichten einer eingebetteten Amazon Quick Sight Q-Suchleiste für anonyme (nicht registrierte) Benutzer.

**Topics**
+ [

## Schritt 1: Festlegen von Berechtigungen
](#embedded-q-bar-for-anonymous-users-step-1)
+ [

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
](#embedded-q-bar-for-anonymous-users-step-2)
+ [

## Schritt 3: Betten Sie die URL der Q-Suchleiste ein
](#embedded-q-bar-for-anonymous-users-step-3)
+ [

## Optionale Funktionen zum Einbetten der Suchleiste von Amazon Quick Sight Q
](#embedded-q-bar-for-anonymous-users-step-4)

## Schritt 1: Festlegen von Berechtigungen
<a name="embedded-q-bar-for-anonymous-users-step-1"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für Ihre Back-End-Anwendung oder Ihren Webserver einrichten, um die Q-Suchleiste einzubetten. Für diese Aufgabe ist Administratorzugriff auf AWS Identity and Access Management (IAM) erforderlich.

Jeder Benutzer, der auf eine Q-Suchleiste zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für die Q-Suchleiste gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem. AWS-Konto Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Die IAM-Rolle muss Berechtigungen zum Abrufen von Einbettungen URLs für einen bestimmten Benutzerpool bereitstellen. 

Mithilfe des Platzhalterzeichens *\$1* können Sie die Berechtigungen zum Generieren einer URL für alle Benutzer in einem bestimmten Namespace gewähren. Sie können auch Berechtigungen zum Generieren einer URL für eine Teilmenge von Benutzern in bestimmten Namespaces gewähren. Dazu fügen Sie `quicksight:GenerateEmbedUrlForAnonymousUser` hinzu.

Sie können in Ihrer IAM-Richtlinie eine Bedingung erstellen, die die Domains einschränkt, die Entwickler im `AllowedDomains`-Parameter einer `GenerateEmbedUrlForAnonymousUser`-API-Operation auflisten können. Der `AllowedDomains`-Parameter ist ein optionaler Parameter. Es gibt Entwicklern die Möglichkeit, die statischen Domains, die im Menü **Amazon Quick Sight verwalten** konfiguriert sind, zu überschreiben und stattdessen bis zu drei Domains oder Subdomains aufzulisten, die auf eine generierte URL zugreifen können. Diese URL wird dann in die Website eines Entwicklers eingebettet. Nur die Domains, die im Parameter aufgeführt sind, können auf die eingebettete Q-Suchleiste zugreifen. Ohne diese Bedingung können Entwickler jede Domain im Internet im `AllowedDomains`-Parameter auflisten. 

Um die Domains einzuschränken, die Entwickler mit diesem Parameter verwenden können, fügen Sie Ihrer IAM-Richtlinie eine `AllowedEmbeddingDomains`-Bedingung hinzu. Weitere Informationen zu dem `AllowedDomains` Parameter finden Sie [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)in der *Amazon Quick Sight API-Referenz*.

**Bewährte Sicherheitsverfahren für IAM-Condition-Operatoren**  
Falsch konfigurierte IAM-Bedingungsoperatoren können über URL-Variationen unbefugten Zugriff auf Ihre eingebetteten Quick-Ressourcen ermöglichen. Verwenden Sie bei der Verwendung des `quicksight:AllowedEmbeddingDomains` Bedingungsschlüssels in Ihren IAM-Richtlinien Bedingungsoperatoren, die entweder bestimmte Domänen zulassen oder alle Domänen verweigern, die nicht ausdrücklich erlaubt sind. Weitere Informationen zu IAM-Bedingungsoperatoren finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) im IAM-Benutzerhandbuch.  
Viele verschiedene URL-Varianten können auf dieselbe Ressource verweisen. Die folgenden Dateien führen beispielsweise URLs alle zu demselben Inhalt:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Wenn in Ihrer Richtlinie Betreiber verwendet werden, die diese URL-Variationen nicht berücksichtigen, kann ein Angreifer Ihre Einschränkungen umgehen, indem er entsprechende URL-Varianten bereitstellt.  
Sie müssen überprüfen, ob Ihre IAM-Richtlinie geeignete Bedingungsoperatoren verwendet, um Sicherheitslücken zu umgehen und sicherzustellen, dass nur die von Ihnen vorgesehenen Domains auf Ihre eingebetteten Ressourcen zugreifen können.

Der IAM-Identität Ihrer Anwendung muss eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben erstellte Rolle zu gewähren. Dies bedeutet: Wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle für den Benutzer übernehmen, um die Q-Suchleiste zu öffnen. Das folgende Beispiel zeigt eine Vertrauensrichtlinie.

------
#### [ 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"
        }
    ]
}
```

------

Weitere Informationen bezüglich Vertrauensrichtlinien finden Sie unter [Temporäre Sicherheitsanmeldeinformationen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*.

## Schritt 2: Generieren Sie die URL mit dem angehängten Authentifizierungscode
<a name="embedded-q-bar-for-anonymous-users-step-2"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Q-Themen-URL auf Ihrem Anwendungsserver abrufen.

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Dann fügt die App den Benutzer zu Amazon Quick Sight hinzu, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/AnonymousUserQSearchBarEmbeddingConfiguration.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/AnonymousUserQSearchBarEmbeddingConfiguration.html).

### Java
<a name="embedded-q-bar-for-anonymous-users-java"></a>

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


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

            private final AmazonQuickSight quickSightClient;

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

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

            public String GenerateEmbedUrlForAnonymousUser(
                final String accountId, // YOUR AWS ACCOUNT ID
                final String initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS AND SEARCHBAR PREPOPULATES INITIALLY
                final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
                final List<String> authorizedResourceArns, // Q SEARCHBAR TOPIC ARN LIST TO EMBED
                final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
                final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
            ) throws Exception {
                AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
                AnonymousUserQSearchBarEmbeddingConfiguration qSearchBarConfiguration = new AnonymousUserQSearchBarEmbeddingConfiguration();
                qSearchBarConfiguration.setInitialTopicId(initialTopicId);
                experienceConfiguration.setQSearchBar(qSearchBarConfiguration);

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

                GenerateEmbedUrlForAnonymousUserResult qSearchBarEmbedUrl = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

                return qSearchBarEmbedUrl.getEmbedUrl();
            }

        }
```

### JavaScript
<a name="embedded-q-bar-for-anonymous-users-js"></a>

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

function generateEmbedUrlForAnonymousUser(
    accountId, // YOUR AWS ACCOUNT ID
    initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS
    quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
    authorizedResourceArns, // Q SEARCHBAR TOPIC ARN LIST TO EMBED
    allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
    sessionTags, // SESSION TAGS USED FOR ROW-LEVEL SECURITY
    generateEmbedUrlForAnonymousUserCallback, // SUCCESS CALLBACK METHOD
    errorCallback // ERROR CALLBACK METHOD
    ) {
    const experienceConfiguration = {
        "QSearchBar": {
            "InitialTopicId": initialTopicId // TOPIC ID CAN BE FOUND IN THE URL ON THE TOPIC AUTHOR PAGE
        }
    };
    
    const generateEmbedUrlForAnonymousUserParams = {
        "AwsAccountId": accountId,
        "Namespace": quicksightNamespace,
        "AuthorizedResourceArns": authorizedResourceArns,
        "AllowedDomains": allowedDomains,
        "ExperienceConfiguration": experienceConfiguration,
        "SessionTags": sessionTags,
        "SessionLifetimeInMinutes": 600
    };

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

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

### Python3
<a name="embedded-q-bar-for-anonymous-users-py"></a>

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

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

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

### Node.js
<a name="embedded-q-bar-for-anonymous-users-nodejs"></a>

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

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

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

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace': 'DEFAULT'
    'AuthorizedResourceArns': '["topic-arn-topicId1","topic-arn-topicId2"]',
    'AllowedDomains': allowedDomains,
    'ExperienceConfiguration': { 
        'QSearchBar': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'SessionTags': '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
    'SessionLifetimeInMinutes': 15
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

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

### .NET/C\$1
<a name="embedded-q-bar-for-anonymous-users-cs"></a>

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für die eingebettete Q-Suchleiste zu generieren. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Q-Suchleiste aufzurufen. 

**Example**  

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

namespace GenerateQSearchBarEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                AnonymousUserQSearchBarEmbeddingConfiguration anonymousUserQSearchBarEmbeddingConfiguration
                    = new AnonymousUserQSearchBarEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        QSearchBar = anonymousUserQSearchBarEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111122223333",
                        Namespace = "DEFAULT",
                        AuthorizedResourceArns '["topic-arn-topicId1","topic-arn-topicId2"]',
                        AllowedDomains = allowedDomains,
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
                        SessionLifetimeInMinutes = 15,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-q-bar-for-anonymous-users-cli"></a>

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GenerateEmbedUrlForAnonymousUser` aktiviert sein.

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGANGSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Für einen Microsoft Windows-Computer verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_q_search_bar_role/QuickSightEmbeddingAnonymousPolicy`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. *Throttling* ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. Darüber hinaus hält sie auch jede Sitzung getrennt und unterscheidbar. Wenn Sie eine Reihe von Webservern verwenden, z. B. für den Lastenausgleich, und eine Sitzung erneut mit einem anderen Server verbunden wird, beginnt eine neue Sitzung.

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie `generate-embed-url-for-anynymous-user` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer generieren, die Ihr Webportal oder Ihre App anonym besuchen.

```
aws quicksight generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId1","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'QSearchBar={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden.

## Schritt 3: Betten Sie die URL der Q-Suchleiste ein
<a name="embedded-q-bar-for-anonymous-users-step-3"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Im folgenden Abschnitt erfahren Sie, wie Sie die Q-Suchleisten-URL aus Schritt 3 in Ihre Website oder Anwendungsseite einbetten. Sie tun dies mit dem [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript). Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie die Q-Suchleiste auf einer HTML-Seite.
+ Übergeben Sie Parameter an die Q-Suchleiste.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GenerateEmbedUrlForAnonymousUser`-API-Operation auf, um die URL zu generieren, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für bis zu 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code`-Wert bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `generate-embed-url-for-anonymous-user`:

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

Betten Sie die Q-Suchleiste in Ihre Webseite ein, indem Sie das [Amazon Quick Sight-Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) verwenden oder diese URL zu einem Iframe hinzufügen. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. 

Stellen Sie dazu sicher, dass die Domain, die die eingebettete Q-Suchleiste hosten soll, auf der *Zulassungsliste* steht, der Liste der zugelassenen Domains für Ihr Amazon Quick Sight-Abonnement. Diese Voraussetzung schützt die Daten, indem unzulässige Domains daran gehindert werden, eingebettete Q-Suchleiste zu hosten. Weitere Informationen zum Hinzufügen von Domains für eine eingebettete Q-Suchleiste finden Sie unter [Domains verwalten und einbetten](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html).

Wenn Sie das Amazon Quick Sight Embedding SDK verwenden, wird die Größe der Q-Suchleiste auf Ihrer Seite je nach Status dynamisch angepasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter in der Q-Suchleiste steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

### SDK 2.0
<a name="embedded-q-bar-for-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

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

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

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

                const contentOptions = {
                    hideTopicName: false, 
                    theme: '<YOUR_THEME_ID>',
                    allowTopicSelection: true,
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                console.log("Do something when Q Search content expanded");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                console.log("Do something when Q Search content collapsed");
                                break;
                            }
                            case 'Q_SEARCH_SIZE_CHANGED': {
                                console.log("Do something when Q Search size changed");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something when the Q Search is loaded.");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the Q Search fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedDashboardExperience = await embeddingContext.embedQSearchBar(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-q-bar-for-anonymous-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Q Search Bar Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.18.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

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

            function onOpen() {
                console.log("Do something when the Q search bar opens");
            }

            function onClose() {
                console.log("Do something when the Q search bar closes");
            }

            function embedQSearchBar() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    width: "1000px",
                    locale: "en-US",
                    qSearchBarOptions: {
                        expandCallback: onOpen,
                        collapseCallback: onClose,
                        iconDisabled: false,
                        topicNameDisabled: false, 
                        themeId: 'bdb844d0-0fe9-4d9d-b520-0fe602d93639',
                        allowTopicSelection: true
                    }
                };
                session = QuickSightEmbedding.embedQSearchBar(options);
                session.on("error", onError);
            }

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

    <body onload="embedQSearchBar()">
        <div id="embeddingContainer"></div>
    </body>

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um die eingebettete Q-Suchleiste auf Ihrer Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

## Optionale Funktionen zum Einbetten der Suchleiste von Amazon Quick Sight Q
<a name="embedded-q-bar-for-anonymous-users-step-4"></a>

**Anmerkung**  
Die eingebettete Amazon Quick Sight Q-Suchleiste bietet das klassische Amazon Quick Sight Q & A-Erlebnis. Amazon Quick Sight lässt sich in Amazon Q Business integrieren, um ein neues generatives Q&A-Erlebnis einzuführen. Entwicklern wird empfohlen, das neue Erlebnis mit generativem Q&A zu nutzen. Weitere Informationen zum eingebetteten generativen Q&A-Erlebnis finden Sie unter [Einbetten des generativen Q&A-Erlebnisses von Amazon Q in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Die folgenden optionalen Funktionen sind für die eingebettete Q-Suchleiste mithilfe des eingebetteten SDK verfügbar. 

### Rufen Sie Aktionen in der Q-Suchleiste auf
<a name="w2aac35c27c21c43c31c17c21b7"></a>

Die folgenden Optionen werden nur für die Einbettung von Q-Suchleisten unterstützt. 
+ Stellen Sie ein Feature in der Q-Suchleiste ein — Dieses Feature sendet eine Frage an die Q-Suchleiste und fragt die Abfrage sofort ab. Außerdem wird das Q-Popover automatisch geöffnet.

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Q-Popover schließen — Dieses Feature schließt das Q-Popover und setzt den iframe auf die ursprüngliche Größe der Q-Suchleiste zurück.

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

Weitere Informationen finden Sie im [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Einbetten von Analysen mithilfe der GetDashboardEmbedURL- und GetSessionEmbedURL-API-Operationen
<a name="embedded-analytics-deprecated"></a>


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Die folgenden API-Operationen zum Einbetten von Amazon Quick Sight-Dashboards und der Amazon Quick Sight-Konsole wurden durch die GenerateEmbedUrlForRegisteredUser API-Operationen GenerateEmbedUrlForAnonymousUser und ersetzt. Sie können sie weiterhin verwenden, um Analysen in Ihre Anwendung einzubetten, aber sie werden nicht mehr verwaltet und enthalten nicht die neuesten Einbettungsfeatures oder -funktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)
+ Die [GetDashboardEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html)API-Operation bettet interaktive Dashboards ein.
+ Die [GetSessionEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html)API-Operation bettet die Amazon Quick Sight-Konsole ein.

**Topics**
+ [

# Einbetten der Dashboards für alle mit GetDashboardEmbedURL (alte API)
](embedded-analytics-dashboards-with-anonymous-users-get.md)
+ [

# Einbetten von Dashboards für registrierte Benutzer mithilfe von GetDashboardEmbedUrl (alten API)
](embedded-analytics-dashboards-for-authenticated-users-get.md)
+ [

# Einbetten der Amazon Quick Sight-Konsole mithilfe GetSessionEmbedUrl (alte API)
](embedded-analytics-full-console-for-authenticated-users-get.md)

# Einbetten der Dashboards für alle mit GetDashboardEmbedURL (alte API)
<a name="embedded-analytics-dashboards-with-anonymous-users-get"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung eingebetteter Amazon Quick Sight-Dashboards für alle (nicht authentifizierte Benutzer) mithilfe einer URL. GetDashboardEmbed

**Topics**
+ [

# Schritt 1: Festlegen von Berechtigungen
](embedded-analytics-dashboards-with-anonymous-users-get-step-1.md)
+ [

# Schritt 2: Abrufen der URL mit dem angehängten Authentifizierungscode
](embedded-analytics-dashboards-with-anonymous-users-get-step-2.md)
+ [

# Schritt 3: Einbetten der Dashboard-URL
](embedded-analytics-dashboards-with-anonymous-users-get-step-3.md)

# Schritt 1: Festlegen von Berechtigungen
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-1"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf ein Dashboard zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für das Dashboard gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem AWS Konto. Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen zur Verwendung mit `IdentityType=ANONYMOUS`. Damit dieser Ansatz funktioniert, benötigen Sie auch ein Sitzungspaket oder eine Preisgestaltung für Sitzungskapazität auf Ihrem AWS Konto. Andernfalls wird der Fehler `UnsupportedPricingPlanException` zurückgegeben, wenn ein Benutzer versucht, auf das Dashboard zuzugreifen. 

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

****  

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

------

Der IAM-Identität Ihrer Anwendung muss eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Dies bedeutet: Wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle für den Benutzer übernehmen, um das Dashboard zu öffnen. Das folgende Beispiel zeigt eine Rolle mit dem Namen `QuickSightEmbeddingAnonymousPolicy`, der die Musterrichtlinie als Ressource vorausgeht. 

Weitere Informationen bezüglich Vertrauensrichtlinien finden Sie unter [Temporäre Sicherheitsanmeldeinformationen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*.

# Schritt 2: Abrufen der URL mit dem angehängten Authentifizierungscode
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-2"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie im Namen des anonymen Besuchers authentifizieren und die einbettungsfähige Dashboard-URL auf Ihrem Anwendungsserver abrufen. 

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Es wird eine ID als eindeutige Rollensitzungs-ID übergeben. Dieser Code wird auf Ihrem App-Server ausgeführt.

------
#### [ Java ]

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlRequest;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlResult;

/**
 * Class to call QuickSight AWS SDK to get url for dashboard embedding.
 */
public class GetQuicksightEmbedUrlNoAuth {

    private static String ANONYMOUS = "ANONYMOUS";

    private final AmazonQuickSight quickSightClient;

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

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

    public String getQuicksightEmbedUrl(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String dashboardId, // YOUR DASHBOARD ID TO EMBED
            final String addtionalDashboardIds, // ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2
            final boolean resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
            final boolean undoRedoDisabled // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    ) throws Exception {
        GetDashboardEmbedUrlRequest getDashboardEmbedUrlRequest = new GetDashboardEmbedUrlRequest()
                .withDashboardId(dashboardId)
                .withAdditionalDashboardIds(addtionalDashboardIds)
                .withAwsAccountId(accountId)
                .withNamespace("default") // Anonymous embedding requires specifying a valid namespace for which you want the embedding url
                .withIdentityType(ANONYMOUS)
                .withResetDisabled(resetDisabled)
                .withUndoRedoDisabled(undoRedoDisabled);

        GetDashboardEmbedUrlResult dashboardEmbedUrl = quickSightClient.getDashboardEmbedUrl(getDashboardEmbedUrlRequest);

        return dashboardEmbedUrl.getEmbedUrl();
    }
}
```

------
#### [ JavaScript ]

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

function getDashboardEmbedURL(
    accountId, // YOUR AWS ACCOUNT ID
    dashboardId, // YOUR DASHBOARD ID TO EMBED
    additionalDashboardIds, // ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2
    quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
    resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
    undoRedoDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    getEmbedUrlCallback, // GETEMBEDURL SUCCESS CALLBACK METHOD
    errorCallback // GETEMBEDURL ERROR CALLBACK METHOD
    ) {
    const getDashboardParams = {
        AwsAccountId: accountId,
        DashboardId: dashboardId,
        AdditionalDashboardIds: additionalDashboardIds,
        Namespace: quicksightNamespace,
        IdentityType: 'ANONYMOUS',
        ResetDisabled: resetDisabled,
        SessionLifetimeInMinutes: 600,
        UndoRedoDisabled: undoRedoDisabled
    };

    const quicksightGetDashboard = new AWS.QuickSight({
        region: process.env.AWS_REGION,
    });

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

------
#### [ Python3 ]

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

# Create QuickSight and STS clients
qs = boto3.client('quicksight',region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL
# accountId: YOUR AWS ACCOUNT ID
# dashboardId: YOUR DASHBOARD ID TO EMBED
# additionalDashboardIds: ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2 WITHOUT COMMAS
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# resetDisabled: PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
# undoRedoDisabled: OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
def getDashboardURL(accountId, dashboardId, quicksightNamespace, resetDisabled, undoRedoDisabled):
    try:
        response = qs.get_dashboard_embed_url(
            AwsAccountId = accountId,
            DashboardId = dashboardId,
            AdditionalDashboardIds = additionalDashboardIds,
            Namespace = quicksightNamespace,
            IdentityType = 'ANONYMOUS',
            SessionLifetimeInMinutes = 600,
            UndoRedoDisabled = undoRedoDisabled,
            ResetDisabled = resetDisabled
        )
            
        return {
            'statusCode': 200,
            'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
            'body': json.dumps(response),
            'isBase64Encoded':  bool('false')
        }
    except ClientError as e:
        print(e)
        return "Error generating embeddedURL: " + str(e)
```

------
#### [ Node.js ]

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard abzurufen. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.getDashboardEmbedUrl({
                'AwsAccountId': '111122223333',
                'DashboardId': 'dashboard-id',
                'AdditionalDashboardIds': 'added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3'
                'Namespace' : 'default',
                'IdentityType': 'ANONYMOUS',
                'SessionLifetimeInMinutes': 100,
                'UndoRedoDisabled': false,
                'ResetDisabled': true
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

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

------
#### [ .NET/C\$1 ]

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard abzurufen. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetDashboardEmbedUrlAsync(new GetDashboardEmbedUrlRequest
                    {
                        AwsAccountId = “111122223333”,
                        DashboardId = "dashboard-id",
                        AdditionalDashboardIds = "added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3",
                        Namespace = default,
                        IdentityType = IdentityType.ANONYMOUS,
                        SessionLifetimeInMinutes = 600,
                        UndoRedoDisabled = false,
                        ResetDisabled = true
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie Security Assertion Markup Language (SAML) zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GetDashboardEmbedURL` aktiviert sein. 

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGANGSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_dashboard_role/QuickSightEmbeddingAnonymousPolicy`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass für jeden besuchenden Benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird jede Sitzung getrennt und unterschiedlich gehalten. Wenn Sie eine Reihe von Webservern verwenden, z. B. für den Lastenausgleich, und eine Sitzung erneut mit einem anderen Server verbunden wird, beginnt eine neue Sitzung.

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie `get-dashboard-embed-url` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer abrufen, die Ihr Webportal oder Ihre App anonym besuchen.

```
aws quicksight get-dashboard-embed-url \
     --aws-account-id 111122223333 \
     --dashboard-id dashboard-id \
     --additional-dashboard-ids added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3
     --namespace default-or-something-else \
     --identity-type ANONYMOUS \
     --session-lifetime-in-minutes 30 \
     --undo-redo-disabled true \
     --reset-disabled true \
     --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/QuickSightEmbeddingAnonymousPolicy/embeddingsession
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden. 

------

# Schritt 3: Einbetten der Dashboard-URL
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-3"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die Dashboard-URL aus Schritt 2 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren des Dashboards auf einer HTML-Seite.
+ Übergeben von Parameter in das Dashboard.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GetDashboardEmbedUrl`-API-Operation auf, um die URL abzurufen, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code` bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `get-dashboard-embed-url`:

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

Betten Sie dieses Dashboard mithilfe des Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) in Ihre Webseite ein oder fügen Sie diese URL zu einem Iframe hinzu. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter im Dashboard steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code befindet sich auf Ihrem App-Server.

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>
    <!-- You can download the latest QuickSight embedding SDK version from https://www.npmjs.com/package/amazon-quicksight-embedding-sdk -->
    <!-- Or you can do "npm install amazon-quicksight-embedding-sdk", if you use npm for javascript dependencies -->
    <script src="./quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard;

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",  
                container: containerDiv,
                scrolling: "no",
                height: "700px",
                width: "1000px",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
        }
    </script>
</head>

<body onload="embedDashboard()">
    <div id="embeddingContainer"></div>
</body>

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Dashboard auf Ihre Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des QuickSight eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

# Einbetten von Dashboards für registrierte Benutzer mithilfe von GetDashboardEmbedUrl (alten API)
<a name="embedded-analytics-dashboards-for-authenticated-users-get"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

In den folgenden Abschnitten finden Sie detaillierte Informationen zur Einrichtung eingebetteter Amazon Quick Sight-Dashboards für registrierte Benutzer mit`GetDashboardEmbedUrl`.

**Topics**
+ [

# Schritt 1: Festlegen von Berechtigungen
](embedded-dashboards-for-authenticated-users-get-step-1.md)
+ [

# Schritt 2: Abrufen der URL mit dem angehängten Authentifizierungscode
](embedded-dashboards-for-authenticated-users-get-step-2.md)
+ [

# Schritt 3: Einbetten der Dashboard-URL
](embedded-dashboards-for-authenticated-users-get-step-3.md)

# Schritt 1: Festlegen von Berechtigungen
<a name="embedded-dashboards-for-authenticated-users-get-step-1"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf ein Dashboard zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für das Dashboard gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem AWS Konto. Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Die IAM-Rolle muss Berechtigungen zum Abrufen des Dashboards bereitstellen. URLs Dazu fügen Sie `quicksight:GetDashboardEmbedUrl` hinzu.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen zur Verwendung mit `IdentityType=IAM`. 

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

****  

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

------

Die folgende Beispielrichtlinie gewährt die Berechtigung zum Abrufen einer Dashboard-URL. Sie verwenden die Richtlinie mit, `quicksight:RegisterUser` wenn Sie Erstbenutzer erstellen, die Amazon Quick Sight-Leser sein sollen. 

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

****  

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

------

Wenn Sie `QUICKSIGHT` als Ihr `identityType` verwenden und den Amazon-Ressourcennamen (ARN) des Benutzers bereitstellen, müssen Sie auch die Aktion `quicksight:GetAuthCode` in Ihrer Richtlinie zulassen. Die folgende Beispielrichtlinie enthält diese Berechtigung.

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

****  

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

------

Der IAM-Identität Ihrer Anwendung muss eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Das heißt, wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle im Namen des Benutzers übernehmen und den Benutzer in Amazon Quick Sight bereitstellen. Das folgende Beispiel zeigt eine Rolle mit dem Namen `embedding_quicksight_dashboard_role`, der die Musterrichtlinie als Ressource vorausgeht. 

Weitere Informationen bezüglich Vertrauensrichtlinien für die OpenId Connect- oder SAML-Authentifizierung finden Sie in den folgenden Abschnitten im *IAM-Benutzerhandbuch: *
+ [Erstellen einer Rolle für Web-Identität oder OpenID-Connect-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Erstellen von Rollen für den SAML 2.0-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# Schritt 2: Abrufen der URL mit dem angehängten Authentifizierungscode
<a name="embedded-dashboards-for-authenticated-users-get-step-2"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Dashboard-URL auf Ihrem Anwendungsserver abrufen. 

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Durch die Ausführung der beschriebenen Schritte wird sichergestellt, dass jeder Viewer des Dashboards in Amazon Quick Sight eindeutig bereitgestellt wird. Dazu werden benutzerspezifische Einstellungen erzwungen, etwa Sicherheit auf niedriger Ebene sowie dynamische Standardwerte für Parameter.

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Dieser Code wird auf Ihrem App-Server ausgeführt.

------
#### [ Java ]

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicSessionCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlRequest;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlResult;
import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
import com.amazonaws.services.securitytoken.model.AssumeRoleRequest;
import com.amazonaws.services.securitytoken.model.AssumeRoleResult;

/**
 * Class to call QuickSight AWS SDK to get url for dashboard embedding.
 */
public class GetQuicksightEmbedUrlIAMAuth {

    private static String IAM = "IAM";

    private final AmazonQuickSight quickSightClient;

    private final AWSSecurityTokenService awsSecurityTokenService;

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

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

    public String getQuicksightEmbedUrl(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String dashboardId, // YOUR DASHBOARD ID TO EMBED
            final String openIdToken, // TOKEN TO ASSUME ROLE WITH ROLEARN
            final String roleArn, // IAM USER ROLE TO USE FOR EMBEDDING
            final String sessionName, // SESSION NAME FOR THE ROLEARN ASSUME ROLE
            final boolean resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
            final boolean undoRedoDisabled // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    ) throws Exception {
        AssumeRoleRequest request = new AssumeRoleRequest()
                .withRoleArn(roleArn)
                .withRoleSessionName(sessionName)
                .withTokenCode(openIdToken)
                .withDurationSeconds(3600);
        AssumeRoleResult assumeRoleResult = awsSecurityTokenService.assumeRole(request);

        AWSCredentials temporaryCredentials = new BasicSessionCredentials(
                assumeRoleResult.getCredentials().getAccessKeyId(),
                assumeRoleResult.getCredentials().getSecretAccessKey(),
                assumeRoleResult.getCredentials().getSessionToken());
        AWSStaticCredentialsProvider awsStaticCredentialsProvider = new AWSStaticCredentialsProvider(temporaryCredentials);

        GetDashboardEmbedUrlRequest getDashboardEmbedUrlRequest = new GetDashboardEmbedUrlRequest()
                .withDashboardId(dashboardId)
                .withAwsAccountId(accountId)
                .withIdentityType(IAM)
                .withResetDisabled(resetDisabled)
                .withUndoRedoDisabled(undoRedoDisabled)
                .withRequestCredentialsProvider(awsStaticCredentialsProvider);

        GetDashboardEmbedUrlResult dashboardEmbedUrl = quickSightClient.getDashboardEmbedUrl(getDashboardEmbedUrlRequest);

        return dashboardEmbedUrl.getEmbedUrl();
    }
}
```

------
#### [ JavaScript ]

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

function getDashboardEmbedURL(
    accountId, // YOUR AWS ACCOUNT ID
    dashboardId, // YOUR DASHBOARD ID TO EMBED
    openIdToken, // TOKEN TO ASSUME ROLE WITH ROLEARN
    roleArn, // IAM USER ROLE TO USE FOR EMBEDDING
    sessionName, // SESSION NAME FOR THE ROLEARN ASSUME ROLE
    resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
    undoRedoDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    getEmbedUrlCallback, // GETEMBEDURL SUCCESS CALLBACK METHOD
    errorCallback // GETEMBEDURL ERROR CALLBACK METHOD
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
    }

    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getDashboardParams = {
                AwsAccountId: accountId,
                DashboardId: dashboardId,
                IdentityType: 'IAM',
                ResetDisabled: resetDisabled,
                SessionLifetimeInMinutes: 600,
                UndoRedoDisabled: undoRedoDisabled
            };

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

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

------
#### [ Python3 ]

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

# Create QuickSight and STS clients
qs = boto3.client('quicksight',region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: YOUR AWS ACCOUNT ID
# dashboardId: YOUR DASHBOARD ID TO EMBED
# openIdToken: TOKEN TO ASSUME ROLE WITH ROLEARN
# roleArn: IAM USER ROLE TO USE FOR EMBEDDING
# sessionName: SESSION NAME FOR THE ROLEARN ASSUME ROLE
# resetDisabled: PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
# undoRedoDisabled: PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
def getDashboardURL(accountId, dashboardId, openIdToken, roleArn, sessionName, resetDisabled, undoRedoDisabled):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
            WebIdentityToken = openIdToken
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quickSight = assumedRoleSession.client('quicksight',region_name='us-east-1')
            
            response = quickSight.get_dashboard_embed_url(
                 AwsAccountId = accountId,
                 DashboardId = dashboardId,
                 IdentityType = 'IAM',
                 SessionLifetimeInMinutes = 600,
                 UndoRedoDisabled = undoRedoDisabled,
                 ResetDisabled = resetDisabled
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embeddedURL: " + str(e)
```

------
#### [ Node.js ]

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard abzurufen. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.getDashboardEmbedUrl({
                'AwsAccountId': '111122223333',
                'DashboardId': '1c1fe111-e2d2-3b30-44ef-a0e111111cde',
                'IdentityType': 'IAM',
                'ResetDisabled': true,
                'SessionLifetimeInMinutes': 100,
                'UndoRedoDisabled': false,
                'StatePersistenceEnabled': true
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

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

------
#### [ .NET/C\$1 ]

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für das eingebettete Dashboard abzurufen. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um das Dashboard aufzurufen. 

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetDashboardEmbedUrlAsync(new GetDashboardEmbedUrlRequest
                    {
                        AwsAccountId = “111122223333”,
                        DashboardId = "1c1fe111-e2d2-3b30-44ef-a0e111111cde",
                        IdentityType = EmbeddingIdentityType.IAM,
                        ResetDisabled = true,
                        SessionLifetimeInMinutes = 100,
                        UndoRedoDisabled = false,
                        StatePersistenceEnabled = true
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS) aus:
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GetDashboardEmbedURL` aktiviert sein. Wenn Sie Benutzer hinzufügen möchten, wenn diese ein just-in-time Dashboard zum ersten Mal öffnen, müssen für die Rolle auch die entsprechenden Berechtigungen aktiviert sein. `quicksight:RegisterUser`

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGRIFFSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_dashboard_role/john.doe@example.com`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. *Throttling* ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. 

Die Rollensitzungs-ID wird auch zum Benutzernamen in Amazon Quick Sight. Sie können dieses Muster verwenden, um Ihre Benutzer im Voraus in Amazon Quick Sight bereitzustellen oder um sie beim ersten Zugriff auf das Dashboard bereitzustellen. 

Das folgende Beispiel zeigt den CLI-Befehl, den Sie verwenden können, um einen Benutzer bereitstellen. Weitere Informationen zu [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), und anderen Amazon Quick Sight API-Vorgängen finden Sie in der [Amazon Quick Sight API-Referenz](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html).

```
aws quicksight register-user \
     --aws-account-id 111122223333 \
     --namespace default \
     --identity-type IAM \
     --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
     --user-role READER \
     --user-name jhnd \
     --session-name "john.doe@example.com" \
     --email john.doe@example.com \
     --region us-east-1 \
     --custom-permissions-name TeamA1
```

Wenn der Benutzer durch Microsoft AD authentifiziert wird, müssen Sie `RegisterUser` nicht verwenden, um sie einzurichten. Stattdessen sollten sie automatisch abonniert werden, wenn sie zum ersten Mal auf Amazon Quick Sight zugreifen. Für Microsoft AD-Benutzer können Sie `DescribeUser` verwenden, um den Benutzer ARN zu erhalten.

Wenn ein Benutzer zum ersten Mal auf Amazon Quick Sight zugreift, können Sie diesen Benutzer auch zu der Gruppe hinzufügen, mit der das Dashboard geteilt wird. Das folgende Beispiel zeigt den CLI-Befehl zum Hinzufügen eines Benutzers zu einer Gruppe.

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

Sie haben jetzt einen Benutzer Ihrer App, der auch Amazon Quick Sight verwendet und Zugriff auf das Dashboard hat. 

Um eine signierte URL für das Dashboard zu erhalten, rufen Sie schließlich `get-dashboard-embed-url` vom App-Server auf. Dies gibt die einbettungsfähige Dashboard-URL zurück. Das folgende Beispiel zeigt, wie Sie die URL für ein eingebettetes Dashboard mithilfe eines serverseitigen Aufrufs für Benutzer abrufen, die über AWS Managed Microsoft AD oder IAM Identity Center authentifiziert wurden.

```
aws quicksight get-dashboard-embed-url \
     --aws-account-id 111122223333 \
     --dashboard-id 1a1ac2b2-3fc3-4b44-5e5d-c6db6778df89 \
     --identity-type IAM \
     --session-lifetime-in-minutes 30 \
     --undo-redo-disabled true \
     --reset-disabled true \
     --state-persistence-enabled true \
     --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_dashboard_role/embeddingsession
```

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden. 

------

# Schritt 3: Einbetten der Dashboard-URL
<a name="embedded-dashboards-for-authenticated-users-get-step-3"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die Dashboard-URL aus Schritt 3 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren des Dashboards auf einer HTML-Seite.
+ Übergeben von Parameter in das Dashboard.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GetDashboardEmbedUrl`-API-Operation auf, um die URL abzurufen, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code` bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `get-dashboard-embed-url`:

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

Betten Sie dieses Dashboard in Ihre Webseite ein, indem Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) verwenden oder indem Sie diese URL zu einem Iframe hinzufügen. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter im Dashboard steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>

    <script src="./quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard;

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",  
                container: containerDiv,
                scrolling: "no",
                height: "700px",
                width: "1000px",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
        }
    </script>
</head>

<body onload="embedDashboard()">
    <div id="embeddingContainer"></div>
</body>

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um das eingebettete Dashboard auf Ihre Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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

# Einbetten der Amazon Quick Sight-Konsole mithilfe GetSessionEmbedUrl (alte API)
<a name="embedded-analytics-full-console-for-authenticated-users-get"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Gilt für: Enterprise Edition  | 


|  | 
| --- |
|    Zielgruppe: Amazon Quick-Entwickler  | 

In den folgenden Abschnitten finden Sie detaillierte Informationen darüber, wie Sie die Amazon Quick Sight-Konsole in einem maßgeschneiderten Autorenportal für registrierte Benutzer bereitstellen können, die die `GetSessionEmbedUrl` API verwenden. 

**Topics**
+ [

# Schritt 1: Festlegen von Berechtigungen
](embedded-analytics-full-console-for-authenticated-users-get-step-1.md)
+ [

# Schritt 2: Abrufen der URL mit dem angehängten Authentifizierungscode
](embedded-analytics-full-console-for-authenticated-users-get-step-2.md)
+ [

# Schritt 3: Betten Sie die URL der Konsolensitzung ein
](embedded-analytics-full-console-for-authenticated-users-get-step-3.md)

# Schritt 1: Festlegen von Berechtigungen
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-1"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Back-End-Anwendung oder den Webserver einrichten. Diese Aufgabe erfordert administrativen Zugriff auf IAM.

Jeder Benutzer, der auf Amazon Quick Sight zugreift, nimmt eine Rolle ein, die ihm Amazon Quick Sight-Zugriff und Berechtigungen für die Konsolensitzung gewährt. Um dies zu ermöglichen, erstellen Sie eine IAM-Rolle in Ihrem AWS Konto. Verknüpfen Sie eine IAM-Richtlinie mit der Rolle, um Berechtigungen für alle Benutzer zu gewähren, die die Rolle annehmen. Fügen Sie `quicksight:RegisterUser` Berechtigungen hinzu, um sicherzustellen, dass der Leser nur lesend auf Amazon Quick Sight zugreifen kann und keinen Zugriff auf andere Daten oder Erstellungsfunktionen hat. Die IAM-Rolle muss außerdem Berechtigungen zum Abrufen der Konsolensitzung bereitstellen. URLs Dazu fügen Sie `quicksight:GetSessionEmbedUrl` hinzu.

Die folgende Beispielrichtlinie gewährt diese Berechtigungen zur Verwendung mit `IdentityType=IAM`. 

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

****  

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

------

Die folgende Beispielrichtlinie gewährt die Berechtigung zum Abrufen einer Konsolensitzungs-URL. Sie verwenden die Richtlinie ohne `quicksight:RegisterUser`, wenn Sie Benutzer erstellen, bevor sie auf eine eingebettete Sitzung zugreifen.

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

****  

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

------

Wenn Sie `QUICKSIGHT` als Ihr `identityType` verwenden und den Amazon-Ressourcennamen (ARN) des Benutzers bereitstellen, müssen Sie auch die Aktion `quicksight:GetAuthCode` in Ihrer Richtlinie zulassen. Die folgende Beispielrichtlinie enthält diese Berechtigung.

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

****  

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

------

Der IAM-Identität Ihrer Anwendung muss eine Vertrauensrichtlinie zugeordnet sein, um den Zugriff auf die soeben von Ihnen erstellte Rolle zu gewähren. Das heißt, wenn ein Benutzer auf Ihre Anwendung zugreift, kann Ihre Anwendung die Rolle im Namen des Benutzers übernehmen und den Benutzer in Amazon Quick Sight bereitstellen. Das folgende Beispiel zeigt eine Rolle mit dem Namen `embedding_quicksight_console_session_role`, der die Musterrichtlinie als Ressource vorausgeht. 

Weitere Informationen bezüglich Vertrauensrichtlinien für die OpenId Connect- oder SAML-Authentifizierung finden Sie in den folgenden Abschnitten im *IAM-Benutzerhandbuch: *
+ [Erstellen einer Rolle für Web-Identität oder OpenID-Connect-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Erstellen von Rollen für den SAML 2.0-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# Schritt 2: Abrufen der URL mit dem angehängten Authentifizierungscode
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-2"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Im folgenden Abschnitt erfahren Sie, wie Sie Ihren Benutzer authentifizieren und die einbettungsfähige Konsolensitzung-URL auf Ihrem Anwendungsserver abrufen. 

Wenn ein Benutzer auf Ihre App zugreift, übernimmt die App die IAM-Rolle für den Benutzer. Anschließend wird der Benutzer zu Amazon Quick Sight hinzugefügt, falls dieser Benutzer noch nicht existiert. Anschließend übergibt sie eine ID als eindeutige Rollensitzungs-ID. 

Durch die Ausführung der beschriebenen Schritte wird sichergestellt, dass jeder Viewer der Konsolensitzung in Amazon Quick Sight eindeutig bereitgestellt wird. Dazu werden benutzerspezifische Einstellungen erzwungen, etwa Sicherheit auf niedriger Ebene sowie dynamische Standardwerte für Parameter.

In den folgenden Beispielen wird die IAM-Authentifizierung im Namen des Benutzers durchgeführt. Dieser Code wird auf Ihrem App-Server ausgeführt.

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

Das folgende Beispiel zeigt die Datei JavaScript (Node.js), die Sie auf dem App-Server verwenden können, um die URL für die eingebettete Konsolensitzung abzurufen. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Konsolensitzung aufzurufen. 

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.GetSessionEmbedUrl({
                'AwsAccountId': '111122223333',
                'EntryPoint': 'https://url-for-console-page-to-open',
                'SessionLifetimeInMinutes': 600,
                'UserArn': 'USER_ARN'
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

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

------
#### [ .NET/C\$1 ]

Das folgende Beispiel zeigt den .NET/C \$1 Code, den Sie auf dem App-Server verwenden können, um die URL für die eingebettete Konsolensitzung abzurufen. Sie können diese URL auf Ihrer Website oder in Ihrer App verwenden, um die Konsole aufzurufen. 

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetSessionEmbedUrlAsync(new GetSessionEmbedUrlRequest
                    {
                'AwsAccountId': '111122223333',
                'EntryPoint': 'https://url-for-console-page-to-open',
                'SessionLifetimeInMinutes': 600,
                'UserArn': 'USER_ARN'
                        AwsAccountId = 111122223333,
                        EntryPoint = https://url-for-console-page-to-open,
                        SessionLifetimeInMinutes = 600,
                        UserArn = 'USER_ARN'
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

Um die Rolle zu übernehmen, wählen Sie eine der folgenden API-Operationen AWS -Security-Token-Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Verwenden Sie diesen Vorgang, wenn Sie eine IAM-Identität verwenden, um die Rolle zu übernehmen.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Verwenden Sie diesen Vorgang, wenn Sie einen Web-Identitätsanbieter verwenden, um Ihren Benutzer zu authentifizieren. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Verwenden Sie diesen Vorgang, wenn Sie SAML zur Authentifizierung Ihrer Benutzer verwenden.

Das folgende Beispiel zeigt den CLI-Befehl zum Festlegen der IAM-Rolle. Für die Rolle müssen die Berechtigungen für `quicksight:GetSessionEmbedUrl` aktiviert sein. Wenn Sie Benutzer hinzufügen möchten, just-in-time wenn diese Amazon Quick Sight zum ersten Mal öffnen, müssen für die Rolle auch die entsprechenden Berechtigungen aktiviert sein`quicksight:RegisterUser`.

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

Die `assume-role`-Operation gibt drei Parameter zurück: den Zugriffsschlüssel, den geheimen Schlüssel und das Sitzungs-Token. 

**Anmerkung**  
Wenn beim Aufrufen der Operation `AssumeRole` der Fehler `ExpiredToken` gemeldet wird, liegt dies wahrscheinlich daran, dass sich der vorherige `SESSION TOKEN`-Wert noch in den Umgebungsvariablen befindet. Deaktivieren Sie dies, indem Sie die folgenden Variablen einstellen:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ZUGRIFFSSCHLÜSSEL* 
*AWS\$1SESSION\$1TOKEN* 

Das folgende Beispiel zeigt, wie Sie diese drei Parameter in der CLI einrichten. Wenn Sie einen Microsoft Windows-Computer nutzen, verwenden Sie `set` anstelle von `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"
```

Diese Befehle setzen die Rollensitzungs-ID des Benutzers, der Ihre Website besucht, auf `embedding_quicksight_console_session_role/john.doe@example.com`. Die Rollensitzungs-ID besteht aus dem Rollennamen `role-arn` und dem `role-session-name`-Wert. Die Verwendung der eindeutigen Rollensitzungs-ID für jeden Benutzer garantiert, dass fpr jeden benutzer die korrekten Berechtigungen eingerichtet werden. Außerdem wird eine Drosselung des Benutzerzugriffs verhindert. Throttling ist eine Sicherheitsfunktion, die verhindert, dass derselbe Benutzer von mehreren Standorten aus auf Amazon Quick Sight zugreift. 

Die Rollensitzungs-ID wird auch zum Benutzernamen in Amazon Quick Sight. Sie können dieses Muster verwenden, um Ihre Benutzer vorab in Amazon Quick Sight bereitzustellen oder um sie beim ersten Zugriff auf eine Konsolensitzung bereitzustellen. 

Das folgende Beispiel zeigt den CLI-Befehl, den Sie verwenden können, um einen Benutzer bereitstellen. Weitere Informationen zu [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), und anderen Amazon Quick Sight API-Vorgängen finden Sie in der [Amazon Quick Sight API-Referenz](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html).

```
aws quicksight register-user \
     --aws-account-id 111122223333 \
     --namespace default \
     --identity-type IAM \
     --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
     --user-role READER \
     --user-name jhnd \
     --session-name "john.doe@example.com" \
     --email john.doe@example.com \
     --region us-east-1 \
     --custom-permissions-name TeamA1
```

Wenn der Benutzer durch Microsoft AD authentifiziert wird, müssen Sie `RegisterUser` nicht verwenden, um sie einzurichten. Stattdessen sollten sie automatisch abonniert werden, wenn sie zum ersten Mal auf Amazon Quick Sight zugreifen. Für Microsoft AD-Benutzer können Sie `DescribeUser` verwenden, um den Benutzer ARN zu erhalten.

Wenn ein Benutzer zum ersten Mal auf Amazon Quick Sight zugreift, können Sie diesen Benutzer auch der entsprechenden Gruppe hinzufügen. Das folgende Beispiel zeigt den CLI-Befehl zum Hinzufügen eines Benutzers zu einer Gruppe.

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

Sie haben jetzt einen Benutzer Ihrer App, der auch Amazon Quick Sight verwendet und Zugriff auf die Amazon Quick Sight-Konsolensitzung hat. 

Um eine signierte URL für die Konsolensitzung zu erhalten, rufen Sie schließlich `get-session-embed-url` vom App-Server auf. Dadurch wird die URL der einbettbaren Konsolensitzung zurückgegeben. Das folgende Beispiel zeigt, wie Sie die URL für eine eingebettete Konsolensitzung mithilfe eines serverseitigen Aufrufs für Benutzer abrufen, die über AWS Managed Microsoft AD oder Single Sign-On (IAM Identity Center) authentifiziert wurden.

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

Weitere Informationen zur Verwendung dieser Operation finden Sie unter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html). Sie können diese und andere API-Operationen in Ihrem eigenen Code verwenden. 

------

# Schritt 3: Betten Sie die URL der Konsolensitzung ein
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-3"></a>

**Wichtig**  
Amazon Quick Sight bietet neue APIs Funktionen zum Einbetten von Analysen: `GenerateEmbedUrlForAnonymousUser` und`GenerateEmbedUrlForRegisteredUser`.  
Sie können weiterhin das `GetDashboardEmbedUrl` und verwenden `GetSessionEmbedUrl` APIs , um Dashboards und die Amazon Quick Sight-Konsole einzubetten, aber sie enthalten nicht die neuesten Einbettungsfunktionen. Aktuelle Informationen zum up-to-date Einbetten finden Sie unter [Einbetten von Amazon Quick Sight-Analysen in Ihre Anwendungen](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Im folgenden Abschnitt erfahren Sie, wie Sie das [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) verwenden können, um die URL der Konsolensitzung aus Schritt 3 in Ihre Website oder Anwendungsseite einzubetten. Mit dem SDK können Sie folgende Aktionen ausführen: 
+ Platzieren Sie die Konsolensitzung auf einer HTML-Seite.
+ Übergeben Sie Parameter an die Konsolensitzung.
+ Umgang mit Fehlerstatus mit Meldungen, die an Ihre Anwendung angepasst wurden.

Rufen Sie die `GetSessionEmbedUrl`-API-Operation auf, um die URL abzurufen, die Sie in Ihre App einbetten können. Diese URL ist für 5 Minuten gültig, die resultierende Sitzung für 10 Stunden. Die API-Operation stellt die URL mit einem `auth_code` bereit, der eine Single-Sign-On-Sitzung unterstützt. 

Es folgt eine Beispielantwort von `get-dashboard-embed-url`:

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

Betten Sie diese Konsolensitzung mithilfe des Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) in Ihre Webseite ein oder fügen Sie diese URL zu einem Iframe hinzu. Wenn Sie eine feste Zahl für Höhe und Breite (in Pixeln) festlegen, verwendet Amazon Quick Sight diese und ändert Ihr Erscheinungsbild nicht, wenn sich die Größe Ihres Fensters ändert. Wenn Sie Höhe und Breite in Prozent angeben, bietet Amazon Quick Sight ein responsives Layout, das sich an die Fenstergröße anpasst. Mithilfe des Amazon Quick Sight Embedding SDK können Sie auch Parameter innerhalb der Konsolensitzung steuern und Rückrufe in Bezug auf den Abschluss des Seitenladevorgangs und Fehler erhalten. 

Im folgenden Beispiel wird gezeigt, wie Sie die generierte URL nutzen. Dieser Code wird auf Ihrem App-Server generiert.

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>

    <script src="./quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard;

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",  
                container: containerDiv,
                scrolling: "no",
                height: "700px",
                width: "1000px",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
        }
    </script>
</head>

<body onload="embedDashboard()">
    <div id="embeddingContainer"></div>
</body>

</html>
```

Damit dieses Beispiel funktioniert, stellen Sie sicher, dass Sie das Amazon Quick Sight Embedding SDK verwenden, um die eingebettete Konsolensitzung auf Ihrer Website mit JavaScript zu laden. Führen Sie für den Erhalt dieser Kopie einen der folgenden Schritte aus:
+ Laden Sie das [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) von GitHub herunter. Dieses Repository wird von einer Gruppe von Amazon Quick Sight-Entwicklern verwaltet.
+ Laden Sie die neueste Version des eingebetteten SDK von [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)herunter.
+ Wenn Sie `npm` for JavaScript dependencies verwenden, laden Sie es herunter und installieren Sie es, indem Sie den folgenden Befehl ausführen.

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