"
]
}
]
}
```
------
# Utiliser des clés CalledVia contextuelles pour Athena
Lorsqu'un [principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-principal) fait une [demande](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-request) à AWS, AWS rassemble les informations de la demande dans un *contexte de demande* qui évalue et autorise la demande. Vous pouvez utiliser l'élément `Condition` d'une politique JSON pour comparer des clés dans le contexte de demande avec les valeurs de clé spécifiées dans votre politique. Les *clés de condition générales* sont des clés de condition avec un préfixe `aws:`.
## À propos de la clé de contexte aws:CalledVia
Vous pouvez utiliser la clé contextuelle de condition générale [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-calledvia](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-calledvia) pour comparer les services de la politique avec les services qui ont fait des demandes au nom du principal IAM (utilisateur ou rôle). Lorsqu'un principal adresse une demande à un Service AWS, ce service peut utiliser les informations d'identification du principal pour faire des demandes ultérieures à d'autres services. La clé `aws:CalledVia` contient une liste ordonnée des services de la chaîne ayant effectué des demandes pour le compte du principal.
En spécifiant un nom principal de service pour la clé de `aws:CalledVia` contexte, vous pouvez la rendre Service AWS spécifique. Par exemple, vous pouvez utiliser la clé de condition `aws:CalledVia` pour limiter les demandes à celles effectuées à partir d'Athena. Pour utiliser la clé de condition `aws:CalledVia` dans une politique avec Athena, vous devez spécifier le `athena.amazonaws.com` du nom du principal du service Athena, comme dans l'exemple suivant.
```
...
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": "athena.amazonaws.com"
}
}
...
```
Vous pouvez utiliser la clé contextuelle `aws:CalledVia` pour vous assurer que les appelants n'ont accès à une ressource (comme une fonction Lambda) que s'ils appellent la ressource à partir d'Athena.
**Note**
La clé de contexte `aws:CalledVia` n’est pas compatible avec la fonctionnalité de propagation d’identité approuvée.
## Ajouter une clé de CalledVia contexte pour accéder aux fonctions Lambda
Athena exige que l'appelant dispose d'autorisations `lambda:InvokeFunction` afin d'invoquer la fonction Lambda associée à la requête. L’instruction suivante spécifie que l’utilisateur peut invoquer des fonctions Lambda uniquement depuis Athena.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:OneAthenaLambdaFunction",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": "athena.amazonaws.com"
}
}
}
]
}
```
------
L'exemple suivant montre l'ajout de l'instruction précédente à une politique qui permet à un utilisateur d'exécuter et de lire une requête fédérée. Les principals autorisés à effectuer ces actions peuvent exécuter des requêtes qui spécifient les catalogues Athena associés à une source de données fédérée. Cependant, le principal ne peut pas accéder à la fonction Lambda associée, à moins que la fonction ne soit invoquée par Athena.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"athena:GetWorkGroup",
"s3:PutObject",
"s3:GetObject",
"athena:StartQueryExecution",
"s3:AbortMultipartUpload",
"athena:StopQueryExecution",
"athena:GetQueryExecution",
"athena:GetQueryResults",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:athena:*:111122223333:workgroup/WorkGroupName",
"arn:aws:s3:::MyQueryResultsBucket/*",
"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillPrefix*"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "athena:ListWorkGroups",
"Resource": "*"
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::MyLambdaSpillBucket"
},
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": [
"arn:aws:lambda:*:111122223333:function:OneAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:function:AnotherAthenaLambdaFunction"
],
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": "athena.amazonaws.com"
}
}
}
]
}
```
------
Pour plus d'informations sur les clés de condition `CalledVia`, consultez la rubrique [Clés contextuelles de condition générale AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) du *Guide de l'utilisateur IAM*.
# Autorisation de l’accès à un connecteur de données Athena pour un metastore Hive externe
Les exemples de politique d'autorisation présentés dans cette rubrique illustrent les actions autorisées requises et les ressources pour lesquelles elles sont autorisées. Examinez attentivement ces politiques et modifiez-les en fonction de vos besoins avant d'attacher des politiques d'autorisation similaires aux identités IAM.
+ [Example Policy to Allow an IAM Principal to Query Data Using Athena Data Connector for External Hive Metastore](#hive-using-iam)
+ [Example Policy to Allow an IAM Principal to Create an Athena Data Connector for External Hive Metastore](#hive-creating-iam)
**Example – Autoriser un principal IAM à interroger des données à l'aide du connecteur de données Athena pour le métastore Hive externe**
La politique suivante est attachée aux principals IAM en plus de [AWS politique gérée : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy), qui accorde un accès complet aux actions Athena.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"lambda:GetFunction",
"lambda:GetLayerVersion",
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:111122223333:function:MyAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:function:AnotherAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:layer:MyAthenaLambdaLayer:*"
]
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillLocation"
}
]
}
```
**Explication des autorisations**
| Actions autorisées | Explication |
| --- | --- |
| "s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
| `s3`les actions permettent de lire et d'écrire dans la ressource spécifiée`"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillLocation"`, où *MyLambdaSpillLocation* identifie le bucket de déversement spécifié dans la configuration de la ou des fonctions Lambda invoquées. L'identifiant de *arn:aws:lambda:\$1:*MyAWSAcctId*:layer:*MyAthenaLambdaLayer*:\$1* ressource n'est requis que si vous utilisez une couche Lambda pour créer des dépendances d'exécution personnalisées afin de réduire la taille des artefacts fonctionnels au moment du déploiement. Le caractère `*` en dernière position est un caractère générique pour la version de la couche. |
| "lambda:GetFunction",
"lambda:GetLayerVersion",
"lambda:InvokeFunction"
| Permet aux requêtes d'invoquer les AWS Lambda fonctions spécifiées dans le Resource bloc. Par exemplearn:aws:lambda:\$1:MyAWSAcctId:function:MyAthenaLambdaFunction, où MyAthenaLambdaFunction indique le nom d'une fonction Lambda à invoquer. Plusieurs fonctions peuvent être spécifiées comme indiqué dans l'exemple. |
**Example – Autoriser un principal IAM à créer un connecteur de données Athena pour le métastore Hive externe**
La politique suivante est attachée aux principals IAM en plus de [AWS politique gérée : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy), qui accorde un accès complet aux actions Athena.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"lambda:GetFunction",
"lambda:ListFunctions",
"lambda:GetLayerVersion",
"lambda:InvokeFunction",
"lambda:CreateFunction",
"lambda:DeleteFunction",
"lambda:PublishLayerVersion",
"lambda:DeleteLayerVersion",
"lambda:UpdateFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:DeleteFunctionConcurrency"
],
"Resource": "arn:aws:lambda:*:111122223333: function: MyAthenaLambdaFunctionsPrefix*"
}
]
}
```
**Explication des autorisations**
Permet aux requêtes d'invoquer les AWS Lambda fonctions pour les AWS Lambda fonctions spécifiées dans le `Resource` bloc. Par exemple`arn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunction`, où *MyAthenaLambdaFunction* indique le nom d'une fonction Lambda à invoquer. Plusieurs fonctions peuvent être spécifiées comme indiqué dans l'exemple.
# Autorisation d'accès des fonctions Lambda aux métastores Hive externes
Pour invoquer une fonction Lambda dans votre compte, vous devez créer un rôle disposant des autorisations suivantes :
+ `AWSLambdaVPCAccessExecutionRole` – Autorisation [rôle d'exécution AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) permettant de gérer des interfaces réseau élastiques qui connectent votre fonction à un VPC. Assurez-vous que vous disposez d'un nombre suffisant d'interfaces réseau et d'adresses IP disponibles.
+ `AmazonAthenaFullAccess`— La politique [AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy)gérée accorde un accès complet à Athéna.
+ Une politique Simple Storage Service (Amazon S3) pour permettre à la fonction Lambda d'écrire sur S3 et à Athena de lire à partir de S3.
Par exemple, la politique suivante définit l'autorisation pour l'emplacement de déversement `s3:\\mybucket\spill`.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [
"s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket", "s3:PutObject" ], "Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/spill" ] } ] }
```
------
Chaque fois que vous utilisez des politiques IAM, veillez à respecter les bonnes pratiques IAM. Pour plus d'informations, consultez la rubrique [Bonnes pratiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) du *Guide de l'utilisateur IAM*.
## Création de fonctions Lambda
Pour créer une fonction Lambda dans votre compte, des autorisations de développement de fonction ou le rôle `AWSLambdaFullAccess` sont nécessaires. Pour de plus amples informations, veuillez consulter la rubrique [Politiques IAM basées sur l'identité pour AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-identity-based.html).
[Comme Athena utilise le AWS Serverless Application Repository pour créer des fonctions Lambda, le superutilisateur ou l'administrateur qui crée des fonctions Lambda doit également disposer de politiques IAM autorisant les requêtes fédérées Athena.](federated-query-iam-access.md)
## Configuration d’autorisations pour les opérations d’enregistrement de catalogue et d’API de métadonnées
Pour accéder à l'API pour l'enregistrement du catalogue et les opérations de métadonnées, vous pouvez utiliser la [politique AmazonAthenaFullAccess gérée](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy). Si vous n’utilisez pas la politique `AmazonAthenaFullAccess`, ajoutez les opérations d’API suivantes à vos politiques Athena :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs",
"athena:GetDataCatalog",
"athena:CreateDataCatalog",
"athena:UpdateDataCatalog",
"athena:DeleteDataCatalog",
"athena:GetDatabase",
"athena:ListDatabases",
"athena:GetTableMetadata",
"athena:ListTableMetadata"
],
"Resource": [
"*"
]
}
]
}
```
------
## Appel d’une fonction Lambda entre régions
Par défaut, Athena invoque des fonctions Lambda définies dans la même région. Pour appeler une fonction Lambda dans une région Région AWS autre que celle dans laquelle vous exécutez les requêtes Athena, utilisez l'ARN complet de la fonction Lambda.
L’exemple suivant montre comment un catalogue de la région Europe (Francfort) peut spécifier une fonction Lambda de la région USA Est (Virginie du Nord) pour extraire des données du metastore Hive de la région Europe (Francfort).
```
arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new
```
Lorsque vous spécifiez l'ARN complet de cette manière, Athena peut appeler la fonction Lambda `external-hms-service-new` sur `us-east-1` pour récupérer les données du métastore Hive à partir de `eu-central-1`.
**Note**
Le catalogue doit être enregistré dans le même répertoire Région AWS que celui que vous utilisez pour exécuter les requêtes Athena.
## Appel d’une fonction Lambda entre comptes
Parfois, vous pouvez avoir besoin d'accéder à un métastore Hive à partir d'un autre compte. Par exemple, vous pouvez exécuter un metastore Hive avec un compte autre que celui utilisé pour les requêtes Athena. Différents groupes ou équipes peuvent exécuter le métastore Hive avec différents comptes à l'intérieur de leur VPC. Vous pouvez également accéder aux métadonnées de différents métastores Hive de différents groupes ou équipes.
Athena utilise la [prise en charge AWS Lambda de l'accès multi-comptes](https://aws.amazon.com/blogs/compute/easy-authorization-of-aws-lambda-functions/) pour permettre l'accès multi-comptes aux métastores Hive.
**Note**
Notez que l'accès entre comptes pour Athena implique normalement un accès inter-comptes pour les métadonnées et les données dans Simple Storage Service (Amazon S3).
Imaginez le scénario suivant :
+ Le compte `111122223333` configure la fonction Lambda `external-hms-service-new` sur us-east-1 dans Athena pour accéder à un métastore Hive exécuté sur un cluster EMR.
+ Le compte `111122223333` veut autoriser le compte 444455556666 à accéder aux données du métastore Hive.
Pour autoriser `444455556666` un compte à accéder à la fonction Lambda`external-hms-service-new`, account `111122223333` utilise la commande suivante AWS CLI `add-permission`. La commande a été formatée pour être lisible.
```
$ aws --profile perf-test lambda add-permission
--function-name external-hms-service-new
--region us-east-1
--statement-id Id-ehms-invocation2
--action "lambda:InvokeFunction"
--principal arn:aws:iam::444455556666:user/perf1-test
{
"Statement": "{\"Sid\":\"Id-ehms-invocation2\",
\"Effect\":\"Allow\",
\"Principal\":{\"AWS\":\"arn:aws:iam::444455556666:user/perf1-test\"},
\"Action\":\"lambda:InvokeFunction\",
\"Resource\":\"arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new\"}"
}
```
Pour vérifier l'autorisation Lambda, utilisez la commande `get-policy`, comme dans l'exemple suivant. La commande a été formatée pour être lisible.
```
$ aws --profile perf-test lambda get-policy
--function-name arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new
--region us-east-1
{
"RevisionId": "711e93ea-9851-44c8-a09f-5f2a2829d40f",
"Policy": "{\"Version\":\"2012-10-17\",
\"Id\":\"default\",
\"Statement\":[{\"Sid\":\"Id-ehms-invocation2\",
\"Effect\":\"Allow\",
\"Principal\":{\"AWS\":\"arn:aws:iam::444455556666:user/perf1-test\"},
\"Action\":\"lambda:InvokeFunction\",
\"Resource\":\"arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new\"}]}"
}
```
Après avoir ajouté l'autorisation, vous pouvez utiliser un ARN complet de la fonction Lambda sur `us-east-1` comme suit lorsque vous définissez le catalogue `ehms` :
```
arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new
```
Pour de plus amples informations sur l’invocation entre régions, veuillez consulter [Appel d’une fonction Lambda entre régions](#hive-metastore-iam-access-lambda-cross-region-invocation) plus haut dans cette rubrique.
### Autorisation d’accès intercompte aux données
Avant de pouvoir exécuter des requêtes Athena, vous devez accorder l'accès inter-comptes aux données dans Simple Storage Service (Amazon S3). Vous pouvez effectuer cette opération de différentes manières :
+ Mettez à jour la politique de la liste de contrôle d'accès du compartiment Simple Storage Service (Amazon S3) avec un [ID utilisateur canonique](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html).
+ Ajoutez l'accès inter-comptes à la politique de compartiment Simple Storage Service (Amazon S3).
Par exemple, ajoutez la politique suivante à la politique de compartiment Simple Storage Service (Amazon S3) du compte `111122223333` pour permettre au compte `444455556666` de lire des données à partir de l'emplacement Simple Storage Service (Amazon S3) spécifié.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1234567890123", "Effect":
"Allow", "Principal": { "AWS":
"arn:aws:iam::444455556666:user/perf1-test"
}, "Action": "s3:GetObject", "Resource": "arn:aws:s3:::athena-test/lambda/dataset/*" } ]
}
```
------
**Note**
Il se peut que vous deviez accorder un accès inter-comptes à Simple Storage Service (Amazon S3) non seulement à vos données, mais aussi à votre emplacement de déversement Simple Storage Service (Amazon S3). Votre fonction Lambda déverse des données supplémentaires à l'emplacement de déversement lorsque la taille de l'objet de réponse dépasse un seuil donné. Veuillez consulter le début de cette rubrique pour obtenir un exemple de politique.
Dans l'exemple actuel, une fois que l'accès entre comptes est accordé à `444455556666,`, `444455556666` peut utiliser le catalogue `ehms` dans son propre `account` pour interroger les tables qui sont définies dans le compte `111122223333`.
Dans l'exemple suivant, le profil SQL Workbench `perf-test-1` est pour le compte `444455556666`. La requête utilise le catalogue `ehms` pour accéder au métastore Hive et aux données Simple Storage Service (Amazon S3) du compte `111122223333`.
![\[Accès inter-comptes aux données du métastore Hive et de Simple Storage Service (Amazon S3) dans SQL Workbench.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/hive-metastore-iam-access-lambda-1.png)
# Autorisations requises pour créer un connecteur et un catalogue Athena
Pour invoquer Athena `CreateDataCatalog`, vous devez créer un rôle disposant des autorisations suivantes :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ECR",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:*:*:repository/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"glue:TagResource",
"glue:GetConnection",
"glue:CreateConnection",
"glue:DeleteConnection",
"glue:UpdateConnection",
"serverlessrepo:CreateCloudFormationTemplate",
"serverlessrepo:GetCloudFormationTemplate",
"cloudformation:CreateStack",
"cloudformation:DeleteStack",
"cloudformation:DescribeStacks",
"cloudformation:CreateChangeSet",
"cloudformation:DescribeAccountLimits",
"cloudformation:CreateStackSet",
"cloudformation:ValidateTemplate",
"cloudformation:CreateUploadBucket",
"cloudformation:DescribeStackDriftDetectionStatus",
"cloudformation:ListExports",
"cloudformation:ListStacks",
"cloudformation:EstimateTemplateCost",
"cloudformation:ListImports",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:DeleteFunction",
"lambda:CreateFunction",
"lambda:TagResource",
"lambda:ListFunctions",
"lambda:GetAccountSettings",
"lambda:ListEventSourceMappings",
"lambda:ListVersionsByFunction",
"lambda:GetFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:UpdateFunctionConfiguration",
"lambda:UpdateFunctionCode",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"lambda:AddPermission",
"lambda:ListTags",
"lambda:GetAlias",
"lambda:GetPolicy",
"lambda:ListAliases",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"secretsmanager:ListSecrets",
"glue:GetCatalogs"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:DetachRolePolicy",
"iam:DeleteRolePolicy",
"iam:PutRolePolicy",
"iam:GetRolePolicy",
"iam:CreateRole",
"iam:TagRole",
"iam:DeleteRole",
"iam:GetRole",
"iam:PassRole",
"iam:ListRoles",
"iam:ListAttachedRolePolicies",
"iam:ListRolePolicies",
"iam:GetPolicy",
"iam:UpdateRole"
],
"Resource": [
"arn:aws:iam::*:role/RoleName",
"arn:aws:iam::111122223333:policy/*"
]
}
]
}
```
------
# Autorisation d’accès aux requêtes fédérées Athena : exemples de politiques
Les exemples de politique d'autorisation présentés dans cette rubrique illustrent les actions autorisées requises et les ressources pour lesquelles elles sont autorisées. Examinez attentivement ces politiques et modifiez-les en fonction de vos besoins avant de les attacher aux identités IAM.
Pour plus d'informations sur l'ajout des politiques aux identités IAM, consultez la rubrique [Ajout et suppression des autorisations d'identité IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) du [Guide de l'utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
+ [Example policy to allow an IAM principal to run and return results using Athena Federated Query](#fed-using-iam)
+ [Example Policy to Allow an IAM Principal to Create a Data Source Connector](#fed-creating-iam)
**Example – Autoriser un principal IAM à exécuter et à renvoyer des résultats à l'aide de la requête fédérée Athena**
La politique d'autorisations basée sur l'identité suivante autorise les actions dont un utilisateur ou un autre principal IAM a besoin pour utiliser la requête fédérée Athena. Les principals autorisés à effectuer ces actions peuvent exécuter des requêtes spécifiant les catalogues Athena associés à une source de données fédérée.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Athena",
"Effect": "Allow",
"Action": [
"athena:GetDataCatalog",
"athena:GetQueryExecution",
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StartQueryExecution",
"athena:StopQueryExecution"
],
"Resource": [
"arn:aws:athena:*:111122223333:workgroup/WorkgroupName",
"arn:aws:athena:us-east-1:111122223333:datacatalog/DataCatalogName"
]
},
{
"Sid": "ListAthenaWorkGroups",
"Effect": "Allow",
"Action": "athena:ListWorkGroups",
"Resource": "*"
},
{
"Sid": "Lambda",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": [
"arn:aws:lambda:*:111122223333:function:OneAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:function:AnotherAthenaLambdaFunction"
]
},
{
"Sid": "S3",
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListMultipartUploadParts",
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::MyLambdaSpillBucket",
"arn:aws:s3:::MyLambdaSpillBucket/*",
"arn:aws:s3:::MyQueryResultsBucket",
"arn:aws:s3:::MyQueryResultsBucket/*"
]
}
]
}
```
**Explication des autorisations**
| Actions autorisées | Explication |
| --- | --- |
| "athena:GetQueryExecution",
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StartQueryExecution",
"athena:StopQueryExecution"
| Autorisations Athena nécessaires pour exécuter des requêtes fédérées. |
| "athena:GetDataCatalog",
"athena:GetQueryExecution,"
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StartQueryExecution",
"athena:StopQueryExecution"
| Autorisations Athena nécessaires pour exécuter des requêtes de vues fédérées. L’action `GetDataCatalog` est requise pour les vues. |
| "lambda:InvokeFunction"
| Permet aux requêtes d'invoquer les AWS Lambda fonctions pour les AWS Lambda fonctions spécifiées dans le Resource bloc. Par exemplearn:aws:lambda:\$1:MyAWSAcctId:function:MyAthenaLambdaFunction, où MyAthenaLambdaFunction indique le nom d'une fonction Lambda à invoquer. Comme illustré dans l’exemple, il est possible de spécifier plusieurs fonctions. |
| "s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListMultipartUploadParts",
"s3:PutObject"
| Les autorisations `s3:ListBucket` et `s3:GetBucketLocation` sont requises pour accéder au compartiment de sortie des requêtes pour les principaux IAM qui exécutent `StartQueryExecution`. `s3:PutObject``s3:ListMultipartUploadParts`, et `s3:AbortMultipartUpload` autorisez l'écriture des résultats de la requête dans tous les sous-dossiers du bucket de résultats de requête tel que spécifié par l'identifiant de `arn:aws:s3:::MyQueryResultsBucket/*` ressource, où se *MyQueryResultsBucket* trouve le bucket de résultats de requête Athena. Pour de plus amples informations, veuillez consulter [Utilisation des résultats des requêtes et des requêtes récentes](querying.md). `s3:GetObject`permet de lire les résultats de la requête et l'historique des requêtes pour la ressource spécifiée sous la forme`arn:aws:s3:::MyQueryResultsBucket`, où se *MyQueryResultsBucket* trouve le bucket de résultats de requête Athena. `s3:GetObject`permet également de lire à partir de la ressource spécifiée sous la forme`"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillPrefix*"`, où *MyLambdaSpillPrefix* est spécifiée dans la configuration de la ou des fonctions Lambda invoquées. |
**Example – Autoriser un principal IAM à créer un connecteur de source de données**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"iam:CreateRole",
"lambda:GetFunctionConfiguration",
"iam:AttachRolePolicy",
"iam:PutRolePolicy",
"lambda:PutFunctionConcurrency",
"iam:PassRole",
"iam:DetachRolePolicy",
"lambda:ListTags",
"iam:ListAttachedRolePolicies",
"iam:DeleteRolePolicy",
"lambda:DeleteFunction",
"lambda:GetAlias",
"iam:ListRolePolicies",
"iam:GetRole",
"iam:GetPolicy",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"iam:DeleteRole",
"lambda:UpdateFunctionCode",
"s3:GetObject",
"lambda:AddPermission",
"iam:UpdateRole",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"iam:GetRolePolicy",
"lambda:GetPolicy"
],
"Resource": [
"arn:aws:lambda:*:111122223333:function:MyAthenaLambdaFunctionsPrefix*",
"arn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/*",
"arn:aws:iam::*:role/RoleName",
"arn:aws:iam::111122223333:policy/*"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"cloudformation:CreateUploadBucket",
"cloudformation:DescribeStackDriftDetectionStatus",
"cloudformation:ListExports",
"cloudformation:ListStacks",
"cloudformation:ListImports",
"lambda:ListFunctions",
"iam:ListRoles",
"lambda:GetAccountSettings",
"ec2:DescribeSecurityGroups",
"cloudformation:EstimateTemplateCost",
"ec2:DescribeVpcs",
"lambda:ListEventSourceMappings",
"cloudformation:DescribeAccountLimits",
"ec2:DescribeSubnets",
"cloudformation:CreateStackSet",
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": "cloudformation:*",
"Resource": [
"arn:aws:cloudformation:*:111122223333:stack/aws-serverless-repository-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:111122223333:stack/serverlessrepo-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:*:transform/Serverless-*",
"arn:aws:cloudformation:*:111122223333:stackset/aws-serverless-repository-MyCFStackPrefix*:*",
"arn:aws:cloudformation:*:111122223333:stackset/serverlessrepo-MyCFStackPrefix*:*"
]
},
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "serverlessrepo:*",
"Resource": "arn:aws:serverlessrepo:*:*:applications/*"
},
{
"Sid": "ECR",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:*:*:repository/*"
}
]
}
```
**Explication des autorisations**
| Actions autorisées | Explication |
| --- | --- |
| "lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"lambda:GetFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:ListTags",
"lambda:DeleteFunction",
"lambda:GetAlias",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"lambda:UpdateFunctionCode",
"lambda:AddPermission",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"lambda:GetPolicy"
"lambda:GetAccountSettings",
"lambda:ListFunctions",
"lambda:ListEventSourceMappings",
| Autoriser la création et la gestion des fonctions Lambda répertoriées en tant que ressources. Dans l’exemple, un préfixe de nom est utilisé dans l’identificateur de ressource `arn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunctionsPrefix*`, où `MyAthenaLambdaFunctionsPrefix` est un préfixe partagé utilisé dans le nom d’un groupe de fonctions Lambda afin qu’il ne soit pas nécessaire de les spécifier individuellement en tant que ressources. Vous pouvez spécifier une ou plusieurs ressources de fonction Lambda. |
| "s3:GetObject"
| Permet de lire un bucket qui AWS Serverless Application Repository nécessite les informations spécifiées par l'identifiant de ressourcearn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/\$1. Ce compartiment peut être spécifique à votre compte. |
| "cloudformation:*"
| Permet la création et la gestion des CloudFormation piles spécifiées par la ressource`MyCFStackPrefix`. Ces piles et ensembles de piles permettent de AWS Serverless Application Repository déployer les connecteurs et. UDFs |
| "serverlessrepo:*"
| Permet de rechercher, d'afficher, de publier et de mettre à jour des applications dans le AWS Serverless Application Repository, spécifié par l'identifiant de ressourcearn:aws:serverlessrepo:\$1:\$1:applications/\$1. |
| "ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
| Permet à la fonction Lambda créée d’accéder à l’image ECR du connecteur de fédération. |
# Autoriser l'accès à Athéna UDFs : exemples de politiques
Les exemples de politique d'autorisation présentés dans cette rubrique illustrent les actions autorisées requises et les ressources pour lesquelles elles sont autorisées. Examinez attentivement ces politiques et modifiez-les en fonction de vos besoins avant d'attacher des politiques d'autorisation similaires aux identités IAM.
+ [Example Policy to Allow an IAM Principal to Run and Return Queries that Contain an Athena UDF Statement](#udf-using-iam)
+ [Example Policy to Allow an IAM Principal to Create an Athena UDF](#udf-creating-iam)
**Example – Autoriser un principal IAM à exécuter et renvoyer des requêtes contenant une instruction UDF Athena**
La politique d'autorisations basée sur l'identité suivante autorise les actions dont un utilisateur ou un autre principal IAM a besoin pour exécuter des requêtes utilisant des instructions UDF Athena.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"lambda:InvokeFunction",
"athena:GetQueryResults",
"s3:ListMultipartUploadParts",
"athena:GetWorkGroup",
"s3:PutObject",
"s3:GetObject",
"s3:AbortMultipartUpload",
"athena:StopQueryExecution",
"athena:GetQueryExecution",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:athena:*:MyAWSAcctId:workgroup/MyAthenaWorkGroup",
"arn:aws:s3:::MyQueryResultsBucket/*",
"arn:aws:lambda:*:MyAWSAcctId:function:OneAthenaLambdaFunction",
"arn:aws:lambda:*:MyAWSAcctId:function:AnotherAthenaLambdaFunction"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "athena:ListWorkGroups",
"Resource": "*"
}
]
}
```
**Explication des autorisations**
| Actions autorisées | Explication |
| --- | --- |
| "athena:StartQueryExecution",
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StopQueryExecution",
"athena:GetQueryExecution",
| Autorisations Athena nécessaires pour exécuter des requêtes dans le groupe de travail `MyAthenaWorkGroup`. |
| "s3:PutObject",
"s3:GetObject",
"s3:AbortMultipartUpload"
| `s3:PutObject`et `s3:AbortMultipartUpload` autorisez l'écriture des résultats de la requête dans tous les sous-dossiers du bucket de résultats de requête tel que spécifié par l'identifiant de `arn:aws:s3:::MyQueryResultsBucket/*` ressource, où se *MyQueryResultsBucket* trouve le bucket de résultats de requête Athena. Pour de plus amples informations, veuillez consulter [Utilisation des résultats des requêtes et des requêtes récentes](querying.md). `s3:GetObject`permet de lire les résultats de la requête et l'historique des requêtes pour la ressource spécifiée sous la forme`arn:aws:s3:::MyQueryResultsBucket`, où se *MyQueryResultsBucket* trouve le bucket de résultats de requête Athena. Pour de plus amples informations, veuillez consulter [Utilisation des résultats des requêtes et des requêtes récentes](querying.md). `s3:GetObject`permet également de lire à partir de la ressource spécifiée sous la forme`"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillPrefix*"`, où *MyLambdaSpillPrefix* est spécifiée dans la configuration de la ou des fonctions Lambda invoquées. |
| "lambda:InvokeFunction"
| Permet aux requêtes d'invoquer les AWS Lambda fonctions spécifiées dans le Resource bloc. Par exemplearn:aws:lambda:\$1:MyAWSAcctId:function:MyAthenaLambdaFunction, où MyAthenaLambdaFunction indique le nom d'une fonction Lambda à invoquer. Plusieurs fonctions peuvent être spécifiées comme indiqué dans l'exemple. |
**Example – Autoriser un principal IAM à créer une UDF Athena**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"iam:CreateRole",
"lambda:GetFunctionConfiguration",
"iam:AttachRolePolicy",
"iam:PutRolePolicy",
"lambda:PutFunctionConcurrency",
"iam:PassRole",
"iam:DetachRolePolicy",
"lambda:ListTags",
"iam:ListAttachedRolePolicies",
"iam:DeleteRolePolicy",
"lambda:DeleteFunction",
"lambda:GetAlias",
"iam:ListRolePolicies",
"iam:GetRole",
"iam:GetPolicy",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"iam:DeleteRole",
"lambda:UpdateFunctionCode",
"s3:GetObject",
"lambda:AddPermission",
"iam:UpdateRole",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"iam:GetRolePolicy",
"lambda:GetPolicy"
],
"Resource": [
"arn:aws:lambda:*:111122223333:function:MyAthenaLambdaFunctionsPrefix*",
"arn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/*",
"arn:aws:iam::*:role/RoleName",
"arn:aws:iam::111122223333:policy/*"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"cloudformation:CreateUploadBucket",
"cloudformation:DescribeStackDriftDetectionStatus",
"cloudformation:ListExports",
"cloudformation:ListStacks",
"cloudformation:ListImports",
"lambda:ListFunctions",
"iam:ListRoles",
"lambda:GetAccountSettings",
"ec2:DescribeSecurityGroups",
"cloudformation:EstimateTemplateCost",
"ec2:DescribeVpcs",
"lambda:ListEventSourceMappings",
"cloudformation:DescribeAccountLimits",
"ec2:DescribeSubnets",
"cloudformation:CreateStackSet",
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": "cloudformation:*",
"Resource": [
"arn:aws:cloudformation:*:111122223333:stack/aws-serverless-repository-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:111122223333:stack/serverlessrepo-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:*:transform/Serverless-*",
"arn:aws:cloudformation:*:111122223333:stackset/aws-serverless-repository-MyCFStackPrefix*:*",
"arn:aws:cloudformation:*:111122223333:stackset/serverlessrepo-MyCFStackPrefix*:*"
]
},
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "serverlessrepo:*",
"Resource": "arn:aws:serverlessrepo:*:*:applications/*"
},
{
"Sid": "ECR",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:*:*:repository/*"
}
]
}
```
**Explication des autorisations**
| Actions autorisées | Explication |
| --- | --- |
| "lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"lambda:GetFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:ListTags",
"lambda:DeleteFunction",
"lambda:GetAlias",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"lambda:UpdateFunctionCode",
"lambda:AddPermission",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"lambda:GetPolicy"
"lambda:GetAccountSettings",
"lambda:ListFunctions",
"lambda:ListEventSourceMappings",
| Autoriser la création et la gestion des fonctions Lambda répertoriées en tant que ressources. Dans l’exemple, un préfixe de nom est utilisé dans l’identificateur de ressource `arn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunctionsPrefix*`, où *MyAthenaLambdaFunctionsPrefix* est un préfixe partagé utilisé dans le nom d’un groupe de fonctions Lambda afin qu’il ne soit pas nécessaire de les spécifier individuellement en tant que ressources. Vous pouvez spécifier une ou plusieurs ressources de fonction Lambda. |
| "s3:GetObject"
| Permet de lire un bucket qui AWS Serverless Application Repository nécessite les informations spécifiées par l'identifiant de ressourcearn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/\$1. |
| "cloudformation:*"
| Permet la création et la gestion des CloudFormation piles spécifiées par la ressource*MyCFStackPrefix*. Ces piles et ensembles de piles permettent de AWS Serverless Application Repository déployer les connecteurs et. UDFs |
| "serverlessrepo:*"
| Permet de rechercher, d'afficher, de publier et de mettre à jour des applications dans le AWS Serverless Application Repository, spécifié par l'identifiant de ressourcearn:aws:serverlessrepo:\$1:\$1:applications/\$1. |
# Autorisation d’accès pour les requêtes ML avec Athena
Les principals IAM qui exécutent des requêtes Athena ML doivent être autorisés à effectuer l'action `sagemaker:invokeEndpoint` pour les points de terminaison Sagemaker qu'ils utilisent. Incluez une déclaration de politique similaire à la suivante dans les politiques d'autorisations basées sur l'identité attachées aux identités utilisateur. En outre, attachez la politique [AWS politique gérée : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy), qui accorde un accès complet aux actions Athena, ou une politique en ligne modifiée qui autorise un sous-ensemble d'actions.
Remplacez `arn:aws:sagemaker:region:AWSAcctID:ModelEndpoint` dans l'exemple par l'ARN ou les points ARNs de terminaison du modèle à utiliser dans les requêtes. Pour plus d'informations, consultez la section [Actions, ressources et clés de condition pour l' SageMaker IA](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonsagemaker.html) dans la *référence d'autorisation de service*.
```
{
"Effect": "Allow",
"Action": [
"sagemaker:invokeEndpoint"
],
"Resource": "arn:aws:sagemaker:us-west-2:123456789012:workteam/public-crowd/default"
}
```
Chaque fois que vous utilisez des politiques IAM, veillez à respecter les bonnes pratiques IAM. Pour plus d'informations, consultez la rubrique [Bonnes pratiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) du *Guide de l'utilisateur IAM*.
# Activation de l’accès fédéré à l’API Athena
Cette section décrit l'accès fédéré qui autorise un utilisateur ou une application cliente de votre organisation à appeler des opérations d'API Amazon Athena. Dans ce cas, les utilisateurs de l'organisation ne disposent pas d'un accès direct à Athena. Au lieu de cela, vous gérez les informations d'identification des utilisateurs AWS en dehors de Microsoft Active Directory. Active Directory prend en charge [SAML 2.0](https://wiki.oasis-open.org/security) (Security Assertion Markup Language 2.0).
Pour authentifier les utilisateurs, utilisez le pilote JDBC ou ODBC avec la prise en charge de SAML 2.0 pour accéder à Active Directory Federation Services (AD FS) 3.0 et permettre à une application cliente d'appeler les opérations d'API Athena.
Pour plus d'informations sur la prise en charge de SAML 2.0 AWS, voir [À propos de la fédération SAML 2.0](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html) dans le guide de l'utilisateur *IAM*.
**Note**
L'accès fédéré à l'API Athena est pris en charge pour un type de fournisseur d'identité (IdP) spécifique, l'Active Directory Federation Service (ADFS 3.0), qui fait partie de Windows Server. L’accès fédéré n’est pas compatible avec la fonctionnalité de propagation d’identité approuvée d’IAM Identity Center. L'accès est établi via les versions des pilotes JDBC ou ODBC prenant en charge SAML 2.0. Pour plus d’informations, consultez [Connexion à Amazon Athena avec JDBC](connect-with-jdbc.md) et [Connexion à Amazon Athena avec ODBC](connect-with-odbc.md).
**Topics**
+ [Avant de commencer](#access-federation-before-you-begin)
+ [Présentation du processus d’authentification](#access-federation-diagram)
+ [Procédure : Activation de l’accès fédéré SAML à l’API Athena](#access-federation-procedure)
## Avant de commencer
Avant de commencer, effectuez les opérations obligatoires suivantes :
+ Dans votre organisation, installez et configurez AD FS 3.0 comme votre fournisseur d'identité.
+ Installez et configurez les dernières versions disponibles des pilotes JDBC ou ODBC sur les clients qui sont utilisés pour l'accès à Athena. Le pilote doit inclure la prise en charge de l'accès fédéré compatible avec SAML 2.0. Pour plus d’informations, consultez [Connexion à Amazon Athena avec JDBC](connect-with-jdbc.md) et [Connexion à Amazon Athena avec ODBC](connect-with-odbc.md).
## Présentation du processus d’authentification
Le schéma suivant illustre le processus d’authentification de l’accès fédéré à l’API Athena.
![\[Le diagramme de l'accès fédéré à l'API Athena.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/athena-saml-based-federation.png)
1. A l'aide d'une application cliente dotée du pilote JDBC ou ODBC, un utilisateur de l'organisation demande son authentification par l'IdP de l'organisation. L'IdP est AD FS 3.0.
1. L'IdP authentifie l'utilisateur par rapport à Active Directory, qui est la base d'identités de l'organisation.
1. L'IdP crée une assertion SAML à l'aide des informations concernant l'utilisateur et l'envoie à l'application cliente via le pilote JDBC ou ODBC.
1. Le pilote JDBC ou ODBC appelle l'opération d'API AWS Security Token Service [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) en lui transmettant les paramètres suivants :
+ L'ARN du fournisseur SAML
+ ARN du rôle à assumer.
+ Assertion SAML de l'IdP
Pour plus d'informations, consultez [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) dans la *référence de l'AWS Security Token Service API*.
1. La réponse de l'API à l'application cliente via le pilote JDBC ou ODBC inclut les informations d'identification de sécurité temporaires.
1. L'application cliente utilise ces informations d'identification de sécurité temporaires pour appeler les opérations d'API Athena, ce qui permet aux utilisateurs d'accéder aux opérations d'API Athena.
## Procédure : Activation de l’accès fédéré SAML à l’API Athena
Cette procédure établit un lien de confiance entre l'IdP de votre organisation et votre AWS compte afin de permettre un accès fédéré basé sur SAML au fonctionnement de l'API Amazon Athena.
**Pour activer l'accès fédéré à l'API Athena :**
1. Dans votre organisation, enregistrez-vous AWS en tant que fournisseur de services (SP) auprès de votre IdP. Ce processus est connu sous le nom d'*approbation des parties utilisatrices*. Pour plus d'informations, consultez la rubrique [Configuration de votre IdP SAML 2.0 à l'aide d'une relation d'approbation des parties utilisatrices](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html) du *Guide de l'utilisateur IAM*. Dans le cadre de cette tâche, effectuez les étapes suivantes :
1. Obtenez l'exemple de document de métadonnées SAML à partir de cette URL : [https://signin.aws.amazon.com/static/saml-metadata.xml](https://signin.aws.amazon.com/static/saml-metadata.xml).
1. Dans l'IdP (ADFS) de votre organisation, générez un fichier XML de métadonnées équivalent qui décrit votre IdP en tant que fournisseur d'identité pour. AWS Votre fichier de métadonnées doit inclure le nom de l'émetteur, la date de création, la date d'expiration et les clés AWS utilisées pour valider les réponses d'authentification (assertions) de votre organisation.
1. Dans la console IAM, créez une entité de fournisseur d'identité SAML. Pour plus d'informations, consultez la rubrique [Création de fournisseurs d'identité SAML](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html) du *Guide de l'utilisateur IAM*. Dans le cadre de cette étape, effectuez ce qui suit :
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Chargez le document de métadonnées SAML généré par l'IdP (AD FS) à l'étape 1 de cette procédure.
1. Dans la console IAM, créez un ou plusieurs rôles IAM pour votre IdP. Pour plus d'informations, consultez la rubrique [Création d'un rôle pour un fournisseur d'identité tiers (fédération)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) du *Guide de l'utilisateur IAM*. Dans le cadre de cette étape, effectuez ce qui suit :
+ Dans la politique d'autorisation du rôle, dressez une liste des actions que les utilisateurs de l'organisation sont autorisés à effectuer dans AWS.
+ Dans la politique d'approbation du rôle, définissez le fournisseur d'identité que vous avez créée à l'étape 2 de cette procédure en tant que principal.
Cela établit une relation de confiance entre votre organisation et AWS.
1. Dans l'IdP de votre organisation (ADFS), vous définissez les assertions qui associent les utilisateurs et les groupes de l'organisation aux rôles IAM. Le mappage des utilisateurs et des groupes aux rôles IAM est également connu sous le nom de *règle de demande*. Notez que différents utilisateurs et groupes de l'organisation peuvent être associés à différents rôles IAM.
Pour plus d'informations sur la configuration du mappage dans ADFS, consultez le billet de blog : [Activation de la fédération à AWS l'aide de Windows Active Directory, ADFS et SAML 2.0](https://aws.amazon.com/blogs/security/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/).
1. Installez et configurez le pilote JDBC ou ODBC avec la prise en charge de SAML 2.0. Pour plus d’informations, consultez [Connexion à Amazon Athena avec JDBC](connect-with-jdbc.md) et [Connexion à Amazon Athena avec ODBC](connect-with-odbc.md).
1. Spécifiez la chaîne de connexion de votre application vers le pilote JDBC ou ODBC. Pour plus d’informations sur la chaîne de connexion que votre application doit utiliser, consultez *Using the Active Directory Federation Services (ADFS) Credentials Provider* dans le *Guide d’installation et de configuration du pilote JDBC* ou une rubrique similaire dans *Guide d’installation et de configuration du pilote ODBC* disponible au téléchargement au format PDF à partir des rubriques [Connexion à Amazon Athena avec JDBC](connect-with-jdbc.md) et [Connexion à Amazon Athena avec ODBC](connect-with-odbc.md).
Le résumé global de la configuration de la chaîne de connexion pour les pilotes est le suivant :
1. Dans `AwsCredentialsProviderClass configuration`, définissez le `com.simba.athena.iamsupport.plugin.AdfsCredentialsProvider` pour indiquer que vous souhaitez utiliser l'authentification basée sur SAML 2.0 via l'IdP AD FS.
1. Pour `idp_host`, fournissez le nom d'hôte du serveur d'IdP AD FS.
1. Pour `idp_port`, fournissez le numéro de port que l'IdP AD FS écoute pour la demande d'assertion SAML.
1. Pour `UID` et `PWD`, fournissez les informations d'identification de l'utilisateur de domaine AD. Lorsque vous utilisez le pilote sur Windows, si `UID` et `PWD` ne sont pas fournis, le pilote tente d'obtenir les informations d'identification de l'utilisateur connecté à la machine Windows.
1. Vous pouvez également définir `ssl_insecure` sur `true`. Dans ce cas, le pilote ne vérifie pas l'authenticité du certificat SSL du serveur de l'IdP AD FS. Le fait de définir sur `true` est nécessaire si le certificat SSL de l'IdP AD FS n'a pas été configuré pour être approuvé par le pilote.
1. Pour activer le mappage d'un utilisateur ou d'un groupe du domaine Active Directory utilisateur à un ou plusieurs rôles IAM (comme indiqué à l'étape 4 de cette procédure), dans le `preferred_role` pour la connexion JDBC ou ODBC, spécifiez le rôle IAM (ARN) à endosser pour le pilote de connexion. La spécification du `preferred_role` est facultative, et elle est utile si le rôle n'est pas le premier répertorié dans la règle de demande.
En conséquence de cette procédure, les actions suivantes se produisent :
1. [Le pilote JDBC ou ODBC appelle l'API AWS STS[AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) et lui transmet les assertions, comme indiqué à l'étape 4 du schéma d'architecture.](#access-federation-diagram)
1. AWS s'assure que la demande pour assumer le rôle provient de l'IdP référencé dans l'entité fournisseur SAML.
1. Si la demande aboutit, l'opération d'API AWS STS [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) renvoie un ensemble d'informations d'identification de sécurité temporaires, que votre application cliente utilise pour envoyer des demandes signées à Athena.
Votre application dispose maintenant d'informations sur l'utilisateur actuel et peut accéder à Athena par programmation.