

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Développement d'applications avec l'API Amazon Quick Sight
<a name="quicksight-sdks"></a>

Vous pouvez gérer la plupart des aspects de votre déploiement en utilisant le AWS SDKs pour accéder à une API adaptée au langage de programmation ou à la plate-forme que vous utilisez. Pour de plus amples informations, veuillez consulter [AWS SDKs](https://aws.amazon.com/tools/#SDKs). 

Pour plus d'informations sur les opérations de l'API, consultez le manuel [Amazon Quick Sight API Reference](https://docs.aws.amazon.com/quicksight/index.html?id=docs_gateway). 

Avant de pouvoir appeler les opérations de l'API Amazon Quick Sight, vous devez `quicksight:operation-name` obtenir l'autorisation dans une politique associée à votre identité IAM. Par exemple, pour appeler `list-users`, vous avez besoin de l’autorisation `quicksight:ListUsers`. Le même modèle s’applique à toutes les opérations.

Si vous ne connaissez pas avec certitude l’autorisation nécessaire, vous pouvez essayer d’effectuer un appel. Le client vous précisera l’autorisation manquante. Vous pouvez utiliser un astérisque (`*`) dans le champ Ressource de votre politique d’autorisation à la place des ressources explicites. Toutefois, nous vous conseillons fortement de restreindre chaque autorisation autant que possible. Nous recommandons toutefois de restreindre chaque autorisation autant que possible. Vous pouvez restreindre l'accès des utilisateurs en spécifiant ou en excluant des ressources dans la politique, à l'aide de leur identifiant Amazon Quick Sight Amazon Resource Name (ARN). 

Pour plus d’informations, consultez les ressources suivantes :
+ [Exemples de politiques IAM pour Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/iam-policy-examples.html)
+ [Actions, ressources et clés de condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonquicksight.html)
+ [Éléments de stratégie JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html)

Pour récupérer l’ARN d’un utilisateur ou d’un groupe, utilisez l’opération `Describe` sur la ressource concernée. Vous pouvez également ajouter des conditions dans IAM pour restreindre encore plus l’accès à une API dans certains scénarios. Par exemple, lorsque vous ajoutez `User1` à`Group1`, la ressource principale est `Group1` que vous pouvez autoriser ou refuser l'accès à certains groupes, mais vous pouvez également ajouter une condition en utilisant la clé IAM Amazon Quick Sight `quicksight:UserName` pour autoriser ou empêcher l'ajout de certains utilisateurs à ce groupe. 

Voici un exemple de stratégie. Cela signifie que le mandataire auquel cette stratégie est attachée est en mesure d’invoquer l’opération `CreateGroupMembership` sur n’importe quel groupe, à condition que le nom d’utilisateur qu’il ajoute au groupe ne soit pas `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 procédure suivante explique comment interagir avec les opérations de l'API Amazon Quick Sight via la AWS CLI. Les instructions suivantes ont été testées dans Bash, mais doivent être identiques ou similaires dans d’autres environnements de ligne de commande.

1. Installez le AWS SDK dans votre environnement. Instructions sur la façon de procéder ici : [AWS Interface de ligne de commande](https://aws.amazon.com/cli/).

1. Configurez l'identité et la région de votre AWS CLI à l'aide des instructions de commande et de suivi suivantes. Utilisez les informations d’identification pour une identité IAM ou un rôle qui dispose des autorisations appropriées. 

   ```
   aws configure
   ```

1. Consultez l'aide du SDK Amazon Quick Sight en exécutant la commande suivante : 

   ```
   aws quicksight help
   ```

1. Pour obtenir des instructions détaillées sur la façon d’utiliser une API, saisissez son nom suivi de « help », comme suit : 

   ```
   aws quicksight list-users help
   ```

1. Vous pouvez désormais appeler une opération d'API Amazon Quick Sight. Cet exemple renvoie la liste des utilisateurs d'Amazon Quick Sight présents dans votre compte. 

   ```
   aws quicksight list-users --aws-account-id aws-account-id --namespace default --region us-east-1
   ```

------
#### [ Java SDK ]

Utilisez la procédure suivante pour configurer une application Java qui interagit avec Amazon Quick Sight. 

1. Pour démarrer, créez un projet Java dans votre IDE.

1. Importez le SDK Amazon Quick Sight dans votre nouveau projet, par exemple : `AWSQuickSightJavaClient-1.11.x.jar`

1. Une fois que votre IDE a indexé le SDK Amazon Quick Sight, vous devriez être en mesure d'ajouter une ligne d'importation comme suit : 

   ```
   import com.amazonaws.services.quicksight.AmazonQuickSight;
   ```

   Si votre IDE ne reconnaît pas ceci comme valide, assurez-vous d’avoir importé le kit de développement logiciel (SDK).

1. Comme les autres AWS SDKs, le SDK Amazon Quick Sight nécessite des dépendances externes pour exécuter bon nombre de ses fonctions. Vous devez télécharger et importer celles-ci dans le même projet. Les dépendances suivantes sont obligatoires :
   + `aws-java-sdk-1.11.402.jar`(Configuration du SDK AWS Java et des informations d'identification) — Voir [Configuration du AWS SDK](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html) pour Java 
   + `commons-logging-1.2.jar`— Voir [https://commons.apache. org/proper/commons-logging/download](https://commons.apache.org/proper/commons-logging/download_logging.cgi)\$1logging.cgi 
   + `jackson-annotations-2.9.6.jar``jackson-core-2.9.6.jar`, et `jackson-databind-2.9.6.jar` — Voir [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` : consultez [https://hc.apache.org/downloads.cgi](https://hc.apache.org/downloads.cgi) (français non garanti) 
   + `joda-time-2.1.jar`— Voir [ https://mvnrepository.com/artifact/joda-time/joda-time/2.1](https://mvnrepository.com/artifact/joda-time/joda-time/2.1) 

1. Vous êtes maintenant prêt à créer un client Amazon Quick Sight. Vous pouvez utiliser un point de terminaison public par défaut avec lequel le client peut communiquer. Vous pouvez également référencer le point de terminaison de façon explicite. Il existe plusieurs manières de fournir vos AWS informations d'identification. Dans l’exemple suivant, nous fournissons une approche simple et directe. La méthode client suivante est utilisée pour effectuer tous les appels d’API suivants :

   ```
   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. Nous pouvons maintenant utiliser le client ci-dessus pour répertorier tous les utilisateurs de notre compte Amazon Quick Sight. 
**Note**  
Vous devez fournir l'identifiant de AWS compte que vous avez utilisé pour vous abonner à Amazon Quick Sight. Il doit correspondre à l'identifiant de AWS compte correspondant à l'identité de l'appelant. Les appels entre comptes ne sont pas pris en charge à l’heure actuelle. En outre, le paramètre requis `namespace` doit toujours être réglé sur*default*. 

   ```
   getClient().listUsers(new ListUsersRequest()
           .withAwsAccountId("relevant_AWS_account_ID")
           .withNamespace("default"))
           .getUserList().forEach(user -> {
               System.out.println(user.getArn());
           });
   ```

1. Pour voir la liste de toutes les opérations d'API possibles et des objets de requête qu'elles utilisent, vous pouvez **cliquer en maintenant la touche Ctrl enfoncée** sur l'objet client dans votre IDE afin d'afficher l'interface Amazon Quick Sight. Vous pouvez également le trouver dans le `com.amazonaws.services.quicksight` package dans le fichier JavaClient JAR Amazon Quick Sight.

------
#### [ JavaScript (Node.js) SDK ]

Utilisez la procédure suivante pour interagir avec Amazon Quick Sight à l'aide de Node.js. 

1. Configurez votre environnement Node à l’aide des commandes suivantes :
   + `npm install aws-sdk`
   + `npm install aws4 `
   + `npm install request`
   + `npm install url`

1. Pour plus d'informations sur la configuration du fichier Node.js avec le AWS SDK et sur la définition de vos informations d'identification, voir -> le [Guide du AWS SDK pour JavaScript développeur pour](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/welcome.html) le SDK v2. 

1. Utilisez l’exemple de code suivant pour tester votre configuration. Le protocole HTTPS est requis. L'exemple affiche une liste complète des opérations Amazon Quick Sight ainsi que leurs paramètres de demande d'URL, suivie de la liste des utilisateurs Amazon Quick Sight de votre compte.

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

Utilisez la procédure suivante pour créer un `botocore` package personnalisé afin d'interagir avec Amazon Quick Sight. 

1. Créez un fichier d'informations d'identification dans le AWS répertoire de votre environnement. Dans un Linux/Mac-based environment, that file is called \$1/.aws/credentials et cela ressemble à ceci :

   ```
   [default]
   aws_access_key_id = Your_IAM_access_key
   aws_secret_access_key = Your_IAM_secret_key
   ```

1. Décompressez le dossier `botocore-1.12.10`. Modifiez le répertoire en `botocore-1.12.10` et saisissez l’environnement d’interpréteur Python3.

1. Les réponses sont renvoyées sous forme d’objet de dictionnaire. Ils ont chacun une `ResponseMetadata` entrée qui contient le statut de la demande IDs et de la réponse. Les autres entrées dépendent du type d’opération exécuté.

1. L’exemple suivant est un exemple d’application qui, dans un premier temps, crée, supprime et répertorie les groupes. Ensuite, il répertorie les utilisateurs dans un compte 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 ]

Utilisez la procédure suivante pour interagir avec Amazon Quick Sight à l'aide de C\$1.NET. Cet exemple s’appuie sur Microsoft Visual pour Mac ; les instructions peuvent varier légèrement en fonction de votre IDE et de votre plateforme. Cependant, elles devraient être relativement similaires.



1. Décompressez le fichier `nuget.zip` dans un dossier intitulé `nuget`.

1. Créez un nouveau projet **Application de console** dans Visual Studio.

1. Dans votre solution, localisez les **dépendances** de l’application, puis ouvrez le menu contextuel d’un clic droit et choisissez **Add Packages (Ajouter des packages)**.

1. Dans la liste des sources, choisissez **Configure Sources (Configurer les sources)**.

1. Choisissez **Add (Ajouter)**, puis attribuez à la source le nom `QuickSightSDK`. Ouvrez le dossier `nuget` et choisissez **Add Source (Ajouter source)**.

1. Choisissez **OK**. Ensuite, une fois `QuickSightSDK` cette option sélectionnée, sélectionnez les trois packages Amazon Quick Sight :
   + `AWSSDK.QuickSight`
   + `AWSSDK.Extensions.NETCore.Setup`
   + `AWSSDK.Extensions.CognitoAuthentication`

1. Cliquez sur **Add Package (Ajouter un package)**. 

1. Copiez et collez l’exemple d’application suivant dans l’éditeur de votre application de 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)
               );
           }
       }
   }
   ```

------