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