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à. # Sviluppo di applicazioni con l'API Amazon Quick Sight Puoi gestire la maggior parte degli aspetti della tua implementazione utilizzando AWS SDKs per accedere a un'API personalizzata per il linguaggio di programmazione o la piattaforma che stai utilizzando. Per ulteriori informazioni, consulta [AWS SDKs](https://aws.amazon.com/tools/#SDKs). Per ulteriori informazioni sulle operazioni delle API, consulta [Amazon Quick Sight API Reference](https://docs.aws.amazon.com/quicksight/index.html?id=docs_gateway). Prima di poter chiamare le operazioni dell'API Amazon Quick Sight, devi `quicksight:operation-name` ottenere l'autorizzazione in una policy allegata alla tua identità IAM. Ad esempio, per chiamare `list-users`, è necessaria l'autorizzazione `quicksight:ListUsers`. Lo stesso modello si applica a tutte le operazioni. Se non sei sicuro di quale sia l'autorizzazione necessaria, puoi provare a effettuare una chiamata. Il cliente ti dice quindi qual è l'autorizzazione mancante. Invece di specificare le risorse esplicite, nel campo Risorse della tua policy di autorizzazione puoi usare un asterisco (`*`). Si consiglia tuttavia di limitare il più possibile le autorizzazioni. Puoi limitare l'accesso degli utenti specificando o escludendo le risorse nella policy, utilizzando il loro identificatore Amazon Quick Sight Amazon Resource Name (ARN). Per ulteriori informazioni, consulta gli argomenti seguenti: + [Esempi di policy IAM per Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/iam-policy-examples.html) + [Operazioni, risorse e chiavi di condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonquicksight.html) + [Elementi delle policy JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) Per recuperare l'ARN di un utente o di un gruppo, utilizza l'operazione `Describe` sulla risorsa rilevante. Puoi anche aggiungere condizioni in IAM per limitare ulteriormente l'accesso a un'API in alcuni scenari. Ad esempio, quando si aggiunge `User1` a`Group1`, la risorsa principale è`Group1`: puoi consentire o negare l'accesso a determinati gruppi, ma puoi anche aggiungere una condizione utilizzando la chiave IAM Amazon Quick Sight `quicksight:UserName` per consentire o impedire l'aggiunta di determinati utenti a quel gruppo. Di seguito è riportato un esempio di policy. Significa che l'intermediario a cui questa policy è collegata è in grado di invocare l'operazione `CreateGroupMembership` su qualsiasi gruppo, a condizione che il nome utente che viene aggiunto al gruppo non sia `user1`. ``` { "Effect": "Allow", "Action": "quicksight:CreateGroupMembership", "Resource": "arn:aws:quicksight:us-east-1:aws-account-id:group/default/*", "Condition": { "StringNotEquals": { "quicksight:UserName": "user1" } } } ``` ------ #### [ AWS CLI ] La procedura seguente spiega come interagire con le operazioni dell'API Amazon Quick Sight tramite la AWS CLI. Le seguenti istruzioni sono state testate in Bash ma dovrebbero essere identiche o simili in altri ambienti a riga di comando. 1. Installa AWS SDK nel tuo ambiente. Le istruzioni si trovano qui: [Interfaccia a riga di comando AWS](https://aws.amazon.com/cli/). 1. Configura l'identità e la regione della AWS CLI utilizzando i seguenti comandi e istruzioni di follow-up. Utilizza le credenziali per un'identità o un ruolo IAM che dispone delle autorizzazioni appropriate. ``` aws configure ``` 1. Consulta l'aiuto di Amazon Quick Sight SDK emettendo il seguente comando: ``` aws quicksight help ``` 1. Per istruzioni dettagliate su come usare un'API, immetti il suo nome seguito da "help", ad esempio: ``` aws quicksight list-users help ``` 1. Ora puoi chiamare un'operazione API Amazon Quick Sight. Questo esempio restituisce un elenco di utenti Amazon Quick Sight nel tuo account. ``` aws quicksight list-users --aws-account-id aws-account-id --namespace default --region us-east-1 ``` ------ #### [ Java SDK ] Utilizza la seguente procedura per configurare un'app Java che interagisce con Amazon Quick Sight. 1. Per iniziare, crea un progetto Java nel tuo IDE. 1. Importa l'SDK Amazon Quick Sight nel tuo nuovo progetto, ad esempio: `AWSQuickSightJavaClient-1.11.x.jar` 1. Una volta che l'IDE indicizza l'SDK Amazon Quick Sight, dovresti essere in grado di aggiungere una riga di importazione come segue: ``` import com.amazonaws.services.quicksight.AmazonQuickSight; ``` Se l'IDE non riconosce questo input come valido, verifica di avere importato l'SDK. 1. Come altri AWS SDKs, Amazon Quick Sight SDK richiede dipendenze esterne per eseguire molte delle sue funzioni. È necessario scaricarle e importarle nello stesso progetto. Le dipendenze seguenti sono obbligatorie: + `aws-java-sdk-1.11.402.jar`(AWS Java SDK e configurazione delle credenziali) — Vedi [Configurazione dell' AWS SDK](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html) per Java + `commons-logging-1.2.jar`[— Vedi mons.apache. https://com org/proper/commons-logging/download\$1logging.cgi](https://commons.apache.org/proper/commons-logging/download_logging.cgi) + `jackson-annotations-2.9.6.jar``jackson-core-2.9.6.jar`, e `jackson-databind-2.9.6.jar` — Vedi [http://repo1.maven. org/maven2/com/fasterxml/jackson/core](https://repo1.maven.org/maven2/com/fasterxml/jackson/core/)/ + `httpclient-4.5.6.jar`, `httpcore-4.4.10.jar`: consulta [https://hc.apache.org/downloads.cgi](https://hc.apache.org/downloads.cgi) + `joda-time-2.1.jar`— Vedi [ https://mvnrepository.com/artifact/joda-time/joda-time/2.1](https://mvnrepository.com/artifact/joda-time/joda-time/2.1) 1. Ora sei pronto per creare un client Amazon Quick Sight. Puoi utilizzare un endpoint pubblico predefinito con cui il client può comunicare o puoi fare riferimento esplicitamente all'endpoint. Esistono diversi modi per fornire le tue AWS credenziali. Nell'esempio seguente viene indicato un approccio diretto e semplice. Il seguente metodo del client viene utilizzato per effettuare le chiamate API seguenti: ``` private static AmazonQuickSight getClient() { final AWSCredentialsProvider credsProvider = 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() {} }; return AmazonQuickSightClientBuilder .standard() .withRegion(Regions.US_EAST_1.getName()) .withCredentials(credsProvider) .build(); } ``` 1. Ora possiamo utilizzare il client di cui sopra per elencare tutti gli utenti nel nostro account Amazon Quick Sight. **Nota** Devi fornire l'ID dell' AWS account che hai usato per abbonarti ad Amazon Quick Sight. Deve corrispondere all'ID AWS account dell'identità del chiamante. Le chiamate tra account non sono supportate in questo momento. Inoltre, il parametro richiesto `namespace` deve essere sempre impostato su. *default* ``` getClient().listUsers(new ListUsersRequest() .withAwsAccountId("relevant_AWS_account_ID") .withNamespace("default")) .getUserList().forEach(user -> { System.out.println(user.getArn()); }); ``` 1. Per visualizzare un elenco di tutte le possibili operazioni API e degli oggetti di richiesta che utilizzano, puoi **fare clic tenendo premuto** il tasto Ctrl sull'oggetto client nel tuo IDE per visualizzare l'interfaccia Amazon Quick Sight. In alternativa, puoi trovarlo all'interno del `com.amazonaws.services.quicksight` pacchetto nel file JavaClient JAR di Amazon Quick Sight. ------ #### [ JavaScript (Node.js) SDK ] Utilizza la seguente procedura per interagire con Amazon Quick Sight utilizzando Node.js. 1. Imposta l'ambiente nodo tramite i seguenti comandi: + `npm install aws-sdk` + `npm install aws4 ` + `npm install request` + `npm install url` 1. Per informazioni sulla configurazione di Node.js con AWS SDK e sull'impostazione delle credenziali, consulta--> la [AWS SDK per JavaScript Developer](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/welcome.html) Guide for SDK v2. 1. Utilizza il seguente codice di esempio per testare la tua configurazione. HTTPS è obbligatorio L'esempio mostra un elenco completo delle operazioni di Amazon Quick Sight insieme ai relativi parametri di richiesta URL, seguito da un elenco di utenti Amazon Quick Sight nel tuo account. ``` 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', }); console.log(quicksight.config.apiConfig.operations); quicksight.listUsers({ // Enter your actual AWS account ID 'AwsAccountId': 'relevant_AWS_account_ID', 'Namespace': 'default', }, function(err, data) { console.log('---'); console.log('Errors: '); console.log(err); console.log('---'); console.log('Response: '); console.log(data); }); ``` ------ #### [ Python3 SDK ] Utilizza la seguente procedura per creare un `botocore` pacchetto personalizzato per interagire con Amazon Quick Sight. 1. Crea un file di credenziali nella AWS directory del tuo ambiente. In un Linux/Mac-based environment, that file is called \$1/.aws/credentials e ha il seguente aspetto: ``` [default] aws_access_key_id = Your_IAM_access_key aws_secret_access_key = Your_IAM_secret_key ``` 1. Decomprimi la cartella `botocore-1.12.10`. Cambia la directory in `botocore-1.12.10` e immetti l'ambiente interprete Python3. 1. Le risposte vengono restituite come un oggetto dizionario. Ciascuno di essi ha una `ResponseMetadata` voce che contiene lo stato della richiesta IDs e della risposta. Le altre voci sono basate sul tipo di operazione che esegui. 1. L'esempio che segue rappresenta un'applicazione che prima crea, elimina ed elenca i gruppi. Quindi, elenca gli utenti in un account Quicksight: ``` import botocore.session default_namespace = 'default' account_id = 'relevant_AWS_Account' session = botocore.session.get_session() client = session.create_client("quicksight", region_name='us-east-1') print('Creating three groups: ') client.create_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup1') client.create_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup2') client.create_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup3') print('Retrieving the groups and listing them: ') response = client.list_groups(AwsAccountId = account_id, Namespace=default_namespace) for group in response['GroupList']: print(group) print('Deleting our groups: ') client.delete_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup1') client.delete_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup2') client.delete_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup3') response = client.list_users(AwsAccountId = account_id, Namespace=default_namespace) for user in response['UserList']: print(user) ``` ------ #### [ .NET/C\$1 SDK ] Utilizza la seguente procedura per interagire con Amazon Quick Sight utilizzando C\$1.NET. Questo esempio è creato su Microsoft Visual per Mac; le istruzioni possono variare leggermente in base alla piattaforma e all'IDE. Tuttavia, dovrebbero essere simili. 1. Decomprimi il file `nuget.zip` in una cartella chiamata `nuget`. 1. Crea un nuovo progetto **Console app (Applicazione console)** in Visual Studio. 1. Nella soluzione, individua **Dependencies (Dipendenze)** dell'app, quindi apri il menu contestuale (clic con il pulsante destro del mouse) e scegli **Add Packages (Aggiungi pacchetti)**. 1. Nell'elenco di origini, scegli **Configure Sources (Configura origini)**. 1. Scegli **Add (Aggiungi)** e denomina l'origine `QuickSightSDK`. Spostati sulla cartella `nuget` e scegli **Add Source (Aggiungi origine)**. 1. Scegli **OK**. Quindi, con `QuickSightSDK` selected, seleziona tutti e tre i pacchetti Amazon Quick Sight: + `AWSSDK.QuickSight` + `AWSSDK.Extensions.NETCore.Setup` + `AWSSDK.Extensions.CognitoAuthentication` 1. Fai clic su **Add Package (Aggiungi pacchetto)**. 1. Copia e incolla la seguente app di esempio nell'editor di app della console. ``` using System; using Amazon.QuickSight.Model; using Amazon.QuickSight; namespace DotNetQuickSightSDKTest { class Program { private static readonly string AccessKey = "insert_your_access_key"; private static readonly string SecretAccessKey = "insert_your_secret_key"; private static readonly string AccountID = "AWS_account_ID"; private static readonly string Namespace = "default"; // leave this as default static void Main(string[] args) { var client = new AmazonQuickSightClient( AccessKey, SecretAccessKey, Amazon.RegionEndpoint.USEast1); var listUsersRequest = new ListUsersRequest { AwsAccountId = AccountID, Namespace = Namespace }; client.ListUsersAsync(listUsersRequest).Result.UserList.ForEach( user => Console.WriteLine(user.Arn) ); var listGroupsRequest = new ListGroupsRequest { AwsAccountId = AccountID, Namespace = Namespace }; client.ListGroupsAsync(listGroupsRequest).Result.GroupList.ForEach( group => Console.WriteLine(group.Arn) ); } } } ``` ------