Développement d'applications avec l' QuickSight API Amazon

Installez le AWS SDK dans votre environnement. Les instructions pour ce faire se trouvent ici : Interface de ligne de AWS commande.

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

Consultez l'aide du QuickSight SDK Amazon en exécutant la commande suivante :

aws quicksight help

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

Vous pouvez désormais appeler une opération d' QuickSight API Amazon. Cet exemple renvoie une liste des QuickSight utilisateurs Amazon de votre compte.

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

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

Importez le QuickSight SDK Amazon dans votre nouveau projet, par exemple : AWSQuickSightJavaClient-1.11.x.jar

Une fois que votre IDE a indexé le QuickSight SDK Amazon, vous devriez pouvoir 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).

Comme les autres AWS SDKs, le QuickSight SDK Amazon 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 :

Vous êtes maintenant prêt à créer un QuickSight client Amazon. 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();
	}

Maintenant, nous pouvons utiliser le client ci-dessus pour répertorier tous les utilisateurs de notre QuickSight compte Amazon.

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

Pour voir une 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. QuickSight Vous pouvez également le trouver dans le com.amazonaws.services.quicksight package dans le fichier Amazon QuickSight JavaClient JAR.

Configurez votre environnement Node à l'aide des commandes suivantes :

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 for JavaScript développeur pour le SDK v2.

Utilisez l'exemple de code suivant pour tester votre configuration. Le protocole HTTPS est requis. L'exemple affiche une liste complète des QuickSight opérations Amazon ainsi que leurs paramètres de demande d'URL, suivie de la liste des QuickSight utilisateurs Amazon 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);
});

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 ~/.aws/credentials et cela ressemble à ceci :

[default]
aws_access_key_id = Your_IAM_access_key
aws_secret_access_key = Your_IAM_secret_key

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.

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é.

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)

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

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

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).

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

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

Choisissez OK. Ensuite, une QuickSightSDK fois sélectionné, sélectionnez les trois QuickSight packages Amazon :

Cliquez sur Add Package (Ajouter un package).

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)
            );
        }
    }
}