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

Date de la dernière mise à jour : 12/08/2022

Je souhaite partager mes jeux de données et mon tableau de bord avec un autre compte AWS dans Amazon QuickSight. Comment procéder ?

Courte description

Vous pouvez utiliser des modèles pour créer un accès intercompte afin de partager votre analyse et votre tableau de bord Amazon QuickSight avec d'autres comptes AWS et régions AWS. Vous pouvez également utiliser les modèles pour créer des tableaux de bord ou d'autres modèles.

Effectuez les étapes suivantes pour fournir un accès intercompte dans QuickSight :

  1. Dans un compte (compte A), créez un nouveau modèle à partir d'une analyse existante.
  2. Dans un autre compte (compte B), créez un jeu de données en utilisant le même schéma que dans le compte A.
  3. Créez un tableau de bord dans le compte B à partir du modèle du compte A.

(Facultatif) Créez un modèle dans le compte B à partir du modèle existant dans le compte A. Utilisez cette option si vous souhaitez déplacer des ressources d'un compte vers un autre et supprimer les ressources du compte source.

Remarque : cet article décrit les étapes d'accès intercompte à l'aide de l’Interface de la ligne de commande AWS (AWS CLI). 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.

Solution

Créer un modèle dans le compte A à partir d’une analyse existante dans le compte A

1.    Utilisez la commande AWS CLI list-dashboards pour répertorier les tableaux de bord disponibles dans votre compte :

aws quicksight list-dashboards --aws-account-id account_a_id

Remarque : remplacez account_a_id par l'identifiant du compte A.

2.    Notez l'identifiant du tableau de bord que vous souhaitez partager.

3.    Utilisez la commande AWS CLI describe-dashboard pour obtenir des détails à partir du tableau de bord :

aws quicksight describe-dashboard --aws-account-id account_a_id --dashboard-id dashboard_id

Remarque : remplacez dashboard_id par l'identifiant de votre tableau de bord.

4.    Créez le fichier JSON du modèle et incluez les ARN de l'analyse et du jeu de données :

{
 "SourceEntity": {
   "SourceAnalysis": {
     "Arn": "arn:aws:quicksight:aws_region:account_a_id:analysis/analysis_id",
     "DataSetReferences": [
       {
         "DataSetPlaceholder": "dataset_name",
         "DataSetArn": "arn:aws:quicksight:aws_region:account_a_id:dataset/dataset_id"
       }
     ]
   }
 },
 "VersionDescription": "1"
}

Remarque : remplacez aws_region par votre région AWS, analysis_id par l'identifiant de votre analyse, dataset_name par le nom du jeu de données et dataset_id par l'identifiant de votre jeu de données.

5.    Créez un modèle dans la même région que votre analyse :

aws quicksight create-template --aws-account-id account_a_id --template-id template_name --cli-input-json file://template.json --profile default

Remarque : remplacez template_name par le nom du modèle pour le compte A.

6.    Vérifiez que le modèle est créé en exécutant la commande d'interface de ligne de commande AWS CLI describe-template :

aws quicksight describe-template --aws-account-id account_a_id --template-id template_id

Remarque : remplacez template_id par l'identifiant de votre modèle. Vérifiez que la réponse de la commande describe-template contient le statut CREATION_SUCCESSFUL (création réussie).

7.    Notez l'ARN du modèle dans les résultats, à utiliser ultérieurement.

8.    Utilisez la commande AWS CLI update-template-permissions pour accorder l'autorisation READ (Lecture) entre comptes du modèle du compte A au compte B :

aws quicksight update-template-permissions --aws-account-id account_a_id --template-id template_id --grant-permissions file://TemplatePermission.json

Exemple de fichier JSON d'autorisation :

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

Remarque : remplacez account_b_id par l'identifiant du compte B. Pour partager le modèle avec plusieurs comptes, incluez la racine de tous les comptes en tant que principale. Vous pouvez partager le modèle uniquement avec le compte racine. L'élément Principal ne prend pas en charge les rôles AWS Identity and Access Management (IAM).

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

Vous ne pouvez pas créer de tableau de bord directement à partir d'un jeu de données situé dans un autre compte. Au lieu de cela, vous devez créer le même jeu de données dans le compte que celui dans lequel vous souhaitez créer le tableau de bord (compte B). Ensuite, créez le tableau de bord à partir du jeu de données nouvellement créé.

1.    Créez le jeu de données dans le compte B.

En utilisant la console Amazon QuickSight

Voir Création de jeux de données.

Utilisation de l'interface de la ligne de commande AWS (AWS CLI)

Utilisez la commande AWS CLI create-data-set :

aws quicksight create-data-set --aws-account-id account_b_id --dataset-id dataset_name --cli-input-json file://datasetB.json

Exemple de fichier de jeu de données JSON :

{
  "Name": "dataset_name",
  "PhysicalTableMap": {
    "Physicaltablename": {
      "RelationalTable": {
         "DataSourceArn": "arn:aws:quicksight:aws_region:account_b_id:datasource/datasource_id",
         "Schema": "schema_name",
         "Name": "table_name",
         "InputColumns": [
           {
             "Name": "column_name",
             "Type": "STRING"|"INTEGER"|"DECIMAL"|"DATETIME"|"BIT"|"BOOLEAN"|"JSON"
           }
        ]
      }
    }
  },
 "LogicalTableMap": {
   "Logicaltablename": {
     "Alias": "any_alias",
     "DataTransforms": [
       {
         "ProjectOperation": {
           "ProjectedColumns": [
             "column_name", "column_name"
         ]
       }
     }
   ],
   "Source": {
     "PhysicalTableId": "Physicaltablename"
   }
  }
 },
 "ImportMode": "SPICE",
 "Permissions": [
   {
     "Principal": "arn:aws:quicksight:aws_region:account_b_id:user/namespace/user_name",
     "Actions": [
       "quicksight:UpdateDataSetPermissions",
       "quicksight:DescribeDataSet",
       "quicksight:DescribeDataSetPermissions",
       "quicksight:PassDataSet",
       "quicksight:DescribeIngestion",
       "quicksight:ListIngestions",
       "quicksight:UpdateDataSet",
       "quicksight:DeleteDataSet",
       "quicksight:CreateIngestion",
       "quicksight:CancelIngestion"
    ]
  }
 ]
}

Remarque : remplacez namespace par votre espace de noms et user_name par le nom de l'utilisateur QuickSight. Remarque : cet exemple fait référence à un jeu de données SPICE.

2.    Vérifiez que le jeu de données a bien été créé :

aws quicksight describe-data-set --aws-account-id account_b_id --data-set-id dataset_id

Vérifiez que la réponse de la commande describe-data-set contient un code d'état 201. Le code d'état 201 signifie que le jeu de données a été créé avec succès.

3.    Notez l'ARN du jeu de données des résultats, à utiliser ultérieurement.

Créez un tableau de bord dans le compte B à partir du modèle dans le compte A

1.    Exécutez la commande suivante et incluez l'ARN du modèle :

aws quicksight create-dashboard --aws-account-id account_b_id --dashboard-id dashboard_id --name dashboard_name --source-entity file://DashboardFromTemplate.json

Remarque : vous pouvez créer le tableau de bord dans une autre région en ajoutant le paramètre --region target_region. Remplacez target_region par la région dans laquelle vous souhaitez créer le modèle.

Exemple de fichier JSON de tableau de bord pour le compte B :

{
 "SourceTemplate": {
   "DataSetReferences": [
     {
       "DataSetPlaceholder": "dataset_name",
       "DataSetArn": "arn:aws:quicksight:aws_region:account_b_id:dataset/dataset_id"
     }
   ],
   "Arn": "arn:aws:quicksight:aws_region:account_a_id:template/template_id"
 }
}

Dans le fichier JSON du tableau de bord précédent :

  • Pour DataSetPlaceholder, vous devez utiliser le même nom de jeu de données que celui du modèle du compte A.
  • Pour DataSetARN, vous devez utiliser l'ARN du jeu de données que vous avez créé dans le compte B.
  • Pour Arn, vous pouvez utiliser l'ARN du modèle que vous avez créé dans le compte A.

2.    Confirmez que le tableau de bord a bien été créé :

aws quicksight describe-dashboard --aws-account-id account_b_id --dashboard-id dashboard_id

Remarque : vérifiez que la réponse de la commande describe-dashboard contient un code d'état 200. Le code d'état 200 signifie que le tableau de bord existe.

3.    Utilisez la commande AWS CLI update-dashboard-permissions pour accorder les autorisations appropriées aux utilisateurs de QuickSight :

aws quicksight update-dashboard-permissions --aws-account-id account_b_id --dashboard-id dashboard_id --grant-permissions file://DashboardPermission.json

Exemple de fichier JSON de tableau de bord :

[
  {
    "Principal": "arn:aws:quicksight:aws_region:account_b_id:user/namespace/quicksight_user_name",
    "Actions": [
      "quicksight:DescribeDashboard",
      "quicksight:ListDashboardVersions",
      "quicksight:UpdateDashboardPermissions",
      "quicksight:QueryDashboard",
      "quicksight:UpdateDashboard",
      "quicksight:DeleteDashboard",
      "quicksight:DescribeDashboardPermissions",
      "quicksight:UpdateDashboardPublishedVersion"
    ]
  }
]

Dans l'exemple de fichier JSON de tableau de bord précédent, l'utilisateur QuickSight bénéficie d'un accès de copropriétaire.

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

"quicksight:DescribeDashboard",
 "quicksight:ListDashboardVersions",
 "quicksight:QueryDashboard"

(Facultatif) Créez un modèle dans le compte B à partir du modèle existant dans le compte A

1.    Vérifiez que votre utilisateur ou rôle IAM dispose des autorisations appropriées. Vous devez disposer des autorisations suivantes pour accéder à un modèle intercompte dans Amazon QuickSight :

{
 "Version": "2012-10-17",
 "Statement": [
   {
     "Effect": "Allow",
     "Resource": "arn:aws:quicksight:aws_region:account_a_id:template/template_id",
     "Action": "quicksight:DescribeTemplate"
   },
   {
     "Effect": "Allow",
     "Resource": "*",
     "Action": "quicksight:CreateTemplate"
   }
 ]
}

2.    Créez un nouveau modèle dans le compte B à partir du modèle du compte A :

aws quicksight create-template --aws-account-id account_b_id --template-id template_name --source-entity file://templateB.json

Remarque : remplacez template_name par le nom du modèle pour le compte B. Pour créer un modèle dans une autre région, ajoutez --region target_region.

Exemple de fichier JSON pour le compte B :

{
   "SourceTemplate": {
    "Arn": "arn:aws:quicksight:region:account_a_id:template/template_id"
    }
}

3.    Confirmez que le modèle est créé :

aws quicksight describe-template --aws-account-id account_b_id --template-id template_id

Remarque : Vérifiez que la réponse de la commande describe-template contient un statut CREATION_SUCCESSFUL (création réussie).


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


Avez-vous besoin d'aide pour une question technique ou de facturation ?