Comment configurer l'accès entre comptes à l'aide de modèles dans Amazon QuickSight ?

Dernière mise à jour : 04/02/2022

J'essaie de créer un accès entre comptes à mon jeu de données et à mon tableau de bord dans Amazon QuickSight. Comment dois-je procéder ?

Brève description

Vous pouvez créer un accès entre comptes à votre jeu de données et à votre tableau de bord QuickSight entre deux comptes AWS. Pour créer l'accès entre comptes, utilisez l'opération d'API CreateTemplate. L'objet d'API template vous permet de créer un modèle à partir d'une analyse ou d'un modèle Amazon QuickSight existant. Ensuite, utilisez l'API CreateDashboard pour créer un tableau de bord.

Important : assurez-vous que les autorisations READ appropriées sont établies à partir du compte source. Une fois les autorisations adéquates établies, vous pouvez créer ou partager un tableau de bord à partir d'un modèle dans un autre compte AWS.

Vous pouvez créer les types d'accès entre comptes suivants dans QuickSight :
  • Créez un nouveau modèle dans un autre compte AWS (compte B) à partir d'un modèle existant (compte A).
  • Créez un tableau de bord dans un autre compte AWS (compte B) à partir d'un modèle existant (compte A).

Remarque : cet article décrit les étapes d'accès entre comptes à l'aide de l'interface de ligne de commande AWS (AWS CLI) ou du kit SDK Boto3. Si vous recevez des erreurs lors de l'exécution de commandes depuis AWS CLI, assurez-vous que vous utilisez la version d'AWS CLI la plus récente.

Résolution

Créer un jeu de données dans le compte B en utilisant le même schéma que le compte A

Créez un jeu de données à l'aide du même schéma que le compte A :

aws quicksight create-data-set --cli-input-json file://<dataset.json>

-ou-

Utilisez la requête du kit SDK Boto3 suivante pour créer un jeu de données dans le compte B en utilisant le même schéma que le compte A :

response = client.create_data_set(
    AwsAccountId='<string>',
    DataSetId='<string>',
    Name='<string>',
     'S3Source': {
                'DataSourceArn': 'arn:aws:quicksight:<region>:<Account-ID>:datasource/<datasource-name>"',
                'InputColumns': [
                {
                "Name": "Col1",
                "Type": "INTEGER"
                },
                {
                "Name": "col2",
                "Type": "DECIMAL"
                },
                {
                "Name": "col3",
                "Type": "INTEGER"
                },
                {
                "Name": "col4",
                "Type": "DECIMAL"
                }
                ]
            },
   ImportMode='SPICE'|'DIRECT_QUERY',
 
)

Dans cet exemple de requête, nous utilisons Amazon Simple Storage Service (Amazon S3) comme source de données.

Pour obtenir l'ARN du jeu de données, utilisez la commande suivante :

aws quicksight list-data-sets --aws-account-id <value>

Créer un modèle dans le compte A à partir de l'analyse existante dans le compte A

Utilisez la commande create-template pour le compte A pour créer un modèle dans la région AWS où réside votre analyse.

Important : vous ne pouvez pas créer de modèles dans différentes régions AWS.

Utilisez la syntaxe de commande AWS CLI suivante pour créer un modèle dans le compte A : 

aws quicksight create-template --aws-account-id <Account_A> --template-id firsttemplate --source-entity file://template.json --profile default

-ou-

Utilisez la requête du kt SDK Boto3 suivante pour créer un modèle dans le compte A :

%config IPCompleter.greedy=True
import boto3
default_namespace = 'default'
account_id = 'Account_A'
client = boto3.client('quicksight')
response = client.create_template( AwsAccountId=account_id, TemplateId='jabsma13', Name='jasbir', SourceEntity={ 'SourceAnalysis': { 'Arn': 'arn:aws:quicksight:us-east-1:12150061445:analysis/198ab579-d3ce-4401-b793-50dd2f81fcd9',
                'DataSetReferences': [ { 'DataSetPlaceholder': 'test', 'DataSetArn': 'arn:aws:quicksight:us-east-1:121500614395:dataset/639111f1-36d2-4873-947a-f94dc9a148bb' }, ] } }, Tags=[ { 'Key': 'jsabir', 'Value': 'singh' }, ], VersionDescription='1'
                )

Voici un exemple de modèle de fichier JSON (template.json) :

{
  "SourceAnalysis": {
    "Arn": "arn:aws:quicksight:<Region of analysis>:<Account_A>:analysis/<Analysis ID>",
    "DataSetReferences": [
      {
        "DataSetPlaceholder": "<Any name>",
        "DataSetArn": "arn:aws:quicksight:<dataset region>:<Account_A>:dataset/<DatasetID>"
      }
    ]
  }
}

Création d'un modèle dans le compte B à partir d'un modèle existant dans le compte A

Pour créer un modèle dans le compte B à partir d'un modèle existant dans le compte A, procédez comme suit :

1.    Dans le compte A, appelez l'API UpdateTemplatePermissions pour accorder l'autorisation READ intercompte du modèle source (compte A) au compte B.

AWS CLI

aws quicksight update-template-permissions --aws-account-id <Account_A> --template-id firsttemplate --grant-permissions file://TemplatePermission.json --profile default

Mettez à jour votre fichier de modèle (TemplatePermission.json) comme ceci : 

[{
    "Principal": "arn:aws:iam::<Account_B>:root",
    "Actions": ["quicksight:UpdateTemplatePermissions", "quicksight:DescribeTemplate"]
}]

Kit SDK Boto3

response_updated_perm = client.update_template_permissions(
    AwsAccountId='Account_A',
    TemplateId='kumo-123',
    GrantPermissions=[
        {
            'Principal': 'arn:aws:iam::<Account_B>:root',
            'Actions': [
                'quicksight:UpdateTemplatePermissions',
                 'quicksight:DescribeTemplate'
            ]
            
        },
    ]
)

print(response_updated_perm

2.    Configurez les autorisations AWS Identity and Access Management (IAM) appropriées pour l'utilisateur IAM (QS-Test) dans le compte B :

{
    "Version": "2012-10-17",
    "Statement": [{
            "Effect": "Allow",
            "Resource": "arn:aws:quicksight:us-east-1:<Account_A>:template/kumo-123",
            "Action": "quicksight:DescribeTemplate"
        },
        {
            "Effect": "Allow",
            "Resource": "*",
            "Action": "quicksight:CreateTemplate"
        }
    ]
}

L'utilisateur IAM (QS-Test) doit avoir l'autorisation d'effectuer les actions suivantes :

quicksight:DescribeTemplate sur le fichier modèle créé dans le compte A QuickSight:CreateTemplate pour créer des modèles dans le compte B

3.    Assumez votre rôle IAM avec les autorisations définies à l'étape 2.

AWS CLI

aws sts assume-role \
     --role-arn "arn:aws:iam::<Account_B>:role/<role_name>" \
     --role-session-name john.doe@example.com

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"

Kit SDK Boto3

/code 
sts_client  = boto3.client('sts')

assumed_role_object=sts_client.assume_role(
    RoleArn="arn:aws:iam::<Account_B>:role/<role_name>",
    RoleSessionName="AssumeRoleSession1"
)

credentials=assumed_role_object['Credentials']

QS=boto3.client(
    'quicksight',
    aws_access_key_id=credentials['AccessKeyId'],
    aws_secret_access_key=credentials['SecretAccessKey'],
    aws_session_token=credentials['SessionToken'],
)

Utilisez les informations d'identification temporaires renvoyées par AssumeRole pour vous connecter à QuickSight.

4.    Créez votre modèle dans le compte B.

AWS CLI

aws quicksight create-template --aws-account-id <Account B ID> --template-id firsttemplate --source-entity file://TemplateFromTemplate.json --profile default

Le fichier modèle dans le compte B (TemplateFromTemplate.json) ressemble à ceci :

{
      "SourceTemplate": {
        "Arn": "arn:aws:quicksight:us-east-1:<Account A ID>:template/firsttemplate"
  }

Kit SDK Boto3

# Create template in Account B

client = boto3.client(
  'quicksight',
  # Hard coded strings as credentials, not recommended.
  aws_access_key_id='xxxxxxx',
  aws_secret_access_key='xxxxxxxxx'
)

response = client.create_template(
    AwsAccountId='Account_B',
    TemplateId='XXXXXXX',
    Name='XXXXXX',
    SourceEntity={
    'SourceTemplate': {
            'Arn': 'arn:aws:quicksight:us-east-1:<Account_A>:template/kumo-123'
        }
    }
)

print(response)

5.    Utilisez l'API list_template pour vérifier le modèle dans le compte B :

AWS CLI

aws quicksight list-templates --aws-account-id <Account B>

Kit SDK Boto3

responsetemplates_B = client.list_templates(
    AwsAccountId='Account_B')

print(responsetemplates_B['TemplateSummaryList'])

Création d'un tableau de bord dans le compte B à partir du modèle que nous venons de créer dans le compte A

1.    Créez un tableau de bord dans le compte B à partir du modèle du compte A. Vous pouvez également créer le tableau de bord à l'aide du modèle nouvellement créé dans le compte B.

AWS CLI

aws quicksight create-dashboard --aws-account-id <Account B ID> --dashboard-id <any ID> --name <any dashboard name> --source-entity file://DashboardFromTemplate.json

Voici un exemple de ce à quoi ressemble le fichier JSON de votre tableau de bord (DashboardFromTemplate.json) :

{
  "SourceTemplate": {
    "DataSetReferences": [
      {
        "DataSetPlaceholder": "placeholder", // the place holder you have provided while creating the template in step 1.
        "DataSetArn": "arn:aws:quicksight:us-east-1:<Account B ID>:dataset/<Dataset ID>"
      }
    ],
    "Arn": "arn:aws:quicksight:us-east-1:<Account B ID>:template/<Template ID>"
  }
}

Kit SDK Boto3

response_dashboard = client.create_dashboard(
    AwsAccountId=Account_B_Id,
    DashboardId='Test',
    Name='test123',
    SourceEntity={
        'SourceTemplate': {
            'DataSetReferences': [
                {
                    'DataSetPlaceholder': 'test',
                    'DataSetArn': 'arn:aws:quicksight:us-east-1:<accountId B>:dataset/639111f1-36d2-4873-947a-f94dc9a148bb'
                },
            ],
            'Arn': 'arn:aws:quicksight:us-east-1:<Accout_A>:template/<TemplateName>'        }
    },
    Tags=[
        {
            'Key': 'test',
            'Value': 'jsb'
        },
    ]
    
        )

print(response_dashboard)

2.    Vérifiez le tableau de bord nouvellement créé :

AWS CLI

aws quicksight list-dashboards \
 --aws-account-id <Account B>

Kit SDK Boto3

response_dashboards_B= client.list_dashboards(
    AwsAccountId='Account_B'
)
print(response_dashboards_A['DashboardSummaryList'])

3.    Accordez l'autorisation IAM au rôle IAM assumé dans le compte B :

Remarque : la stratégie IAM peut être limitée à des actions spécifiques. Veillez à mettre à jour les autorisations du nouveau tableau de bord, sinon il ne sera pas visible dans la console QuickSight.

AWS CLI

aws quicksight update-dashboard-permissions --aws-account-id <Account_B> --dashboard-id <dashboard-id> --cli-input-json file://DashboardPermission.json

Cette syntaxe de commande accorde au rôle IAM (QS-TEST) un accès complet au tableau de bord QuickSight. Vous pouvez mettre à jour les autorisations du nouveau tableau de bord à l'aide de la commande update-dashboard-permissions.

Kit SDK Boto3

response = client.update_dashboard_permissions(AwsAccountId='string',DashboardId='string',GrantPermissions=[{'Principal': 'string','Actions': ['string',]},],RevokePermissions=[{'Principal': 'string','Actions': ['string',]},])

Voici un exemple de ce à quoi ressemble le fichier JSON de votre tableau de bord (DashboardPermission.json) :

[
  {
    "Principal": "arn:aws:quicksight:us-east-1:<Account_A ID >:user/default/<Quicksight user name>", // arn of the QuickSight user you want to assign ownership
    "Actions": ["quicksight:DescribeDashboard","quicksight:ListDashboardVersions","quicksight:UpdateDashboardPermissions","quicksight:QueryDashboard","quicksight:UpdateDashboard","quicksight:DeleteDashboard","quicksight:DescribeDashboardPermissions","quicksight:UpdateDashboardPublishedVersion"]
  }
]

Les autorisations répertoriées dans ce fichier de modèle vous accordent l'accès en tant que copropriétaire du tableau de bord.

Pour fournir un accès en lecture seule à d'autres utilisateurs, spécifiez les autorisations suivantes : 

quicksight:DescribeDashboard
quicksight:ListDashboardVersions quicksight:QueryDashboard

Dans l'exemple suivant, l'accès complet est accordé à l'aide de l'expression générique « quicksight:* » :

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

Cet article vous a-t-il été utile ?

Envoyer un commentaire

Besoin d'aide pour une question technique ou de facturation ?

Contactez AWS Support