Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Incorporamento di pannelli di controllo per tutti gli utenti tramite GetDashboardEmbedURL (vecchia API)
<a name="embedded-analytics-dashboards-with-anonymous-users-get"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare dashboard Amazon Quick Sight integrate per tutti (utenti non autenticati) tramite URL. GetDashboardEmbed

**Topics**
+ [Fase 1: Configurazione delle autorizzazioni](embedded-analytics-dashboards-with-anonymous-users-get-step-1.md)
+ [Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato](embedded-analytics-dashboards-with-anonymous-users-get-step-2.md)
+ [Fase 3: Incorporamento dell'URL del pannello di controllo](embedded-analytics-dashboards-with-anonymous-users-get-step-3.md)

# Fase 1: Configurazione delle autorizzazioni
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-1"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nella sezione seguente viene descritto come configurare le autorizzazioni per l'applicazione di back-end o il server Web. Questa operazione richiede l'accesso amministrativo a IAM.

Ogni utente che accede a un pannello di controllo assume un ruolo che gli consente l'accesso e le autorizzazioni di accesso ad Amazon Quick Sight. Per rendere possibile tutto ciò, crea un ruolo IAM nel tuo account. AWS Associa una policy IAM al ruolo per fornire le autorizzazioni a qualsiasi utente che lo assume.

La seguente policy di esempio fornisce le autorizzazioni da utilizzare con `IdentityType=ANONYMOUS`. Affinché questo approccio funzioni, hai anche bisogno di un pacchetto di sessioni, o prezzi relativi alla capacità della sessione, sul tuo AWS account. Altrimenti, quando un utente prova ad accedere al pannello di controllo, viene restituito l'errore `UnsupportedPricingPlanException`. 

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

****  

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

------

È necessario che all'identità IAM dell'applicazione sia associata una policy di attendibilità per consentire l'accesso al ruolo appena creato. Ciò significa che, quando un utente accede all'applicazione, l'applicazione può assumere quel ruolo per conto dell'utente per aprire il pannello di controllo. L'esempio seguente mostra un ruolo chiamato `QuickSightEmbeddingAnonymousPolicy`, che è la policy di esempio elencata in precedenza come risorsa. 

Per ulteriori informazioni sulle policy di attendibilità, consulta [Credenziali di sicurezza provvisorie in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) nella *Guida per l'utente di IAM*.

# Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-2"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nella sezione seguente, è possibile scoprire come eseguire l'autenticazione per conto del visitatore anonimo e ottenere l'URL del pannello di controllo incorporabile nel server delle applicazioni. 

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi aggiunge l'utente ad Amazon Quick Sight, se quell'utente non esiste già. In seguito, sarà necessario passare un identificatore come l'ID della sessione del ruolo univoco. 

Gli esempi seguenti eseguono l'autenticazione IAM per conto dell'utente. Passa un identificatore come l'ID della sessione del ruolo univoco. Questo codice viene eseguito sul server delle applicazioni.

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

L'esempio seguente mostra JavaScript (Node.js) che puoi usare sul server dell'app per ottenere l'URL della dashboard incorporata. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare il pannello di controllo. 

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

L'esempio seguente mostra il codice .NET/C \$1 che è possibile utilizzare nel server app per ottenere l'URL per il pannello di controllo incorporato. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare il pannello di controllo. 

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

Per assumere il ruolo, scegliete una delle seguenti operazioni API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Utilizzate questa operazione quando utilizzate un'identità IAM per assumere il ruolo.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Utilizzate questa operazione quando utilizzate un provider di identità web per autenticare l'utente. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Utilizzate questa operazione quando utilizzate Security Assertion Markup Language (SAML) per autenticare gli utenti.

L'esempio seguente mostra il comando dell'interfaccia a riga di comando per impostare il ruolo IAM. Il ruolo deve avere le autorizzazioni abilitate per `quicksight:GetDashboardEmbedURL`. 

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

L'operazione `assume-role` restituisce tre parametri di output: la chiave di accesso, la chiave segreta e il token della sessione. 

**Nota**  
Se si verifica un errore `ExpiredToken` durante la chiamata all'operazione `AssumeRole`, vuol dire che il `SESSION TOKEN` precedente è ancora presente nelle variabili di ambiente. Cancellala impostando le seguenti variabili:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHIAVE\$1ACCESSO* 
*AWS\$1SESSION\$1GETTONE* 

L'esempio seguente mostra come impostare questi tre parametri nell'interfaccia a riga di comando. Se usi un computer Microsoft Windows, utilizza `set` invece di `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"
```

L'esecuzione di questi comandi imposta l'ID della sessione del ruolo dell'utente che visita la pagina del tuo sito web su`embedding_quicksight_dashboard_role/QuickSightEmbeddingAnonymousPolicy`. L'ID della sessione del ruolo è costituito dal nome del ruolo di `role-arn` e dal valore `role-session-name`. L'utilizzo dell'ID della sessione del ruolo univoco per ciascun utente garantisce che le autorizzazioni appropriate siano impostate per ogni utente visitatore. Inoltre, mantiene ogni sessione separata e distinta. Se utilizzi una serie di server Web, ad esempio per il bilanciamento del carico, e una sessione viene ricollegata a un server diverso, viene avviata una nuova sessione.

Per ottenere un URL firmato per il pannello di controllo, chiama `get-dashboard-embed-url` dal server delle applicazioni. Questo restituisce l'URL del pannello di controllo incorporato. L'esempio seguente mostra come generare l'URL per un pannello di controllo incorporato utilizzando una chiamata lato server per gli utenti che effettuano visite anonime al portale Web o all'applicazione.

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

Per ulteriori informazioni sull'utilizzo di questa operazione, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html). Puoi utilizzare questa API e altre operazioni nel tuo codice. 

------

# Fase 3: Incorporamento dell'URL del pannello di controllo
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-3"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nella sezione seguente, puoi scoprire come utilizzare l'[SDK di incorporamento di Amazon Quick Sight (JavaScript) per incorporare](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) l'URL della dashboard dal passaggio 2 nella pagina del tuo sito Web o dell'applicazione. Con il kit SDK, puoi procedere come segue: 
+ Posiziona il pannello di controllo in una pagina HTML.
+ Passare i parametri nel pannello di controllo.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GetDashboardEmbedUrl` per ottenere l'URL da incorporare nell'applicazione. Questo URL è valido per 5 minuti, mentre la sessione risultante è valida per 10 ore. L'operazione API fornisce l'URL con un `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `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"
}
```

Incorpora questa dashboard nella tua pagina Web utilizzando l'[SDK Amazon Quick Sight Embedding](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) o aggiungendo questo URL in un iframe. Se imposti un numero fisso di altezza e larghezza (in pixel), Amazon Quick Sight li utilizza e non modifica la visualizzazione durante il ridimensionamento della finestra. Se imposti un'altezza e una larghezza percentuali relative, Amazon Quick Sight fornisce un layout reattivo che viene modificato al variare delle dimensioni della finestra. Utilizzando Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri all'interno della dashboard e ricevere callback in termini di completamento del caricamento della pagina ed errori. 

Il seguente esempio illustra come utilizzare l'URL generato. Questo codice si trova sul server delle applicazioni.

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

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare la dashboard incorporata sul tuo sito Web utilizzando. JavaScript Per ottenere la tua copia, procedi in uno dei seguenti modi:
+ Scarica l'[SDK di incorporamento Amazon Quick Sight da.](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) GitHub Questo repository è gestito da un gruppo di sviluppatori di Amazon Quick Sight.
+ Scarica l'ultima versione dell'SDK QuickSight di incorporamento da. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se lo utilizzi `npm` per JavaScript le dipendenze, scaricalo e installalo eseguendo il comando seguente.

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