* par le nom du rôle du flux de travail.
| Type de politique | Politique |
| --- | --- |
| AWS politique gérée | AWSGlueConsoleFullAccess |
| Politique en ligne (de base) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/permissions-reference.html) |
| Politique intégrée (pour les opérations sur les tables gouvernées, y compris les opérations au sein des transactions) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/permissions-reference.html) |
| Politique en ligne (pour le contrôle d'accès aux métadonnées à l'aide de la méthode de contrôle d'accès basée sur les balises Lake Formation (LF-TBAC)) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/permissions-reference.html) |
| Politique intégrée (politique de passe-rôle pour le rôle de flux de travail) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/permissions-reference.html) |
### Autorisations d'analyse de données
| Type de politique | Politique |
| --- | --- |
| AWS politique gérée | AmazonAthenaFullAccess |
| Politique en ligne (de base) | {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"glue:GetTable",
"glue:GetTables",
"glue:SearchTables",
"glue:GetDatabase",
"glue:GetDatabases",
"glue:GetPartitions",
"lakeformation:GetResourceLFTags",
"lakeformation:ListLFTags",
"lakeformation:GetLFTag",
"lakeformation:SearchTablesByLFTags",
"lakeformation:SearchDatabasesByLFTags"
],
"Resource": "*"
}
]
} |
| (Facultatif) Politique intégrée (pour les opérations sur les tables gouvernées, y compris les opérations au sein des transactions) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/permissions-reference.html) |
### Autorisations relatives aux rôles du flux
Ce rôle dispose des autorisations requises pour exécuter un flux de travail. Vous spécifiez un rôle doté de ces autorisations lorsque vous créez un flux de travail.
**Important**
Dans les politiques suivantes, remplacez-le ** par un identifiant de AWS région valide (par exemple`us-east-1`), ** par un numéro de AWS compte valide, ** par le nom du rôle du flux de travail et ** par le chemin Amazon S3 vers vos AWS CloudTrail journaux.
| Type de politique | Politique |
| --- | --- |
| AWS politique gérée | AWSGlueServiceRole |
| Politique en ligne (accès aux données) | {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Lakeformation",
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"lakeformation:GrantPermissions"
],
"Resource": "*"
}
]
} |
| Politique intégrée (politique de passe-rôle pour le rôle de flux de travail) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/permissions-reference.html) |
| Politique en ligne (pour l'ingestion de données en dehors du lac de données, AWS CloudTrail par exemple des journaux) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/permissions-reference.html) |
# Modification des paramètres par défaut de votre lac de données
Pour maintenir la rétrocompatibilité avecAWS Glue, AWS Lake Formation possède les paramètres de sécurité initiaux suivants :
+ L'`Super`autorisation est accordée au groupe `IAMAllowedPrincipals` sur toutes les ressources du catalogue de AWS Glue données existantes.
+ Les paramètres « Utiliser uniquement le contrôle d'accès IAM » sont activés pour les nouvelles ressources du catalogue de données.
Ces paramètres font en sorte que l'accès aux ressources du catalogue de données et aux emplacements Amazon S3 soit contrôlé uniquement par des politiques Gestion des identités et des accès AWS (IAM). Les autorisations individuelles de Lake Formation ne sont pas en vigueur.
Le `IAMAllowedPrincipals` groupe inclut tous les utilisateurs et rôles IAM autorisés à accéder aux ressources de votre catalogue de données par vos politiques IAM. L'`Super`autorisation permet au principal d'effectuer toutes les opérations de Lake Formation prises en charge sur la base de données ou la table pour laquelle elle est accordée.
Pour modifier les paramètres de sécurité afin que l'accès aux ressources du catalogue de données (bases de données et tables) soit géré par les autorisations de Lake Formation, procédez comme suit :
1. Modifiez les paramètres de sécurité par défaut pour les nouvelles ressources. Pour obtenir des instructions, veuillez consulter [Modifier le modèle d'autorisation par défaut ou utiliser le mode d'accès hybride](initial-lf-config.md#setup-change-cat-settings).
1. Modifiez les paramètres des ressources du catalogue de données existantes. Pour obtenir des instructions, veuillez consulter [Mise à niveau AWS Glue des autorisations de données vers le AWS Lake Formation modèle](upgrade-glue-lake-formation.md).
**Modification des paramètres de sécurité par défaut à l'aide de l'opération d'`PutDataLakeSettings`API Lake Formation**
Vous pouvez également modifier les paramètres de sécurité par défaut à l'aide de l'opération d'[PutDataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_PutDataLakeSettings.html)API Lake Formation. Cette action prend comme arguments un ID de catalogue facultatif et une [DataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_DataLakeSettings.html)structure.
Pour renforcer le contrôle d'accès aux métadonnées et aux données sous-jacentes par Lake Formation sur les nouvelles bases de données et tables, codez la `DataLakeSettings` structure comme suit.
**Note**
**Remplacez-le par un identifiant de AWS compte valide et ** par un nom d'utilisateur IAM valide. Vous pouvez définir plusieurs utilisateurs en tant qu'administrateurs de data lake.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
],
"CreateDatabaseDefaultPermissions": [],
"CreateTableDefaultPermissions": []
}
}
```
Vous pouvez également coder la structure comme suit. L'omission du `CreateTableDefaultPermissions` paramètre `CreateDatabaseDefaultPermissions` or équivaut à transmettre une liste vide.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
]
}
}
```
Cette action révoque effectivement toutes les autorisations de Lake Formation accordées au `IAMAllowedPrincipals` groupe sur les nouvelles bases de données et tables. Lorsque vous créez une base de données, vous pouvez annuler ce paramètre.
Pour appliquer le contrôle d'accès aux métadonnées et aux données sous-jacentes uniquement par IAM sur les nouvelles bases de données et tables, codez la `DataLakeSettings` structure comme suit.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
],
"CreateDatabaseDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
],
"CreateTableDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
]
}
}
```
Cela permet à la `Super` Lake Formation d'autoriser le `IAMAllowedPrincipals` groupe à utiliser de nouvelles bases de données et de nouvelles tables. Lorsque vous créez une base de données, vous pouvez annuler ce paramètre.
**Note**
Dans la `DataLakeSettings` structure précédente, la seule valeur autorisée pour `DataLakePrincipalIdentifier` est`IAM_ALLOWED_PRINCIPALS`, et la seule valeur autorisée pour `Permissions` est`ALL`.
# Permissions implicites de Lake Formation
AWS Lake Formation accorde les autorisations implicites suivantes aux administrateurs de lacs de données, aux créateurs de bases de données et aux créateurs de tables.
**Administrateurs de lacs de données**
+ `Describe`Accédez à toutes les ressources du catalogue de données, à l'exception des ressources partagées directement depuis un autre compte avec un autre principal. Cet accès ne peut pas être révoqué auprès d'un administrateur.
+ Disposez d'autorisations de localisation des données partout dans le lac de données.
+ Peut accorder ou révoquer l'accès à toutes les ressources du catalogue de données à n'importe quel principal (y compris lui-même). Cet accès ne peut pas être révoqué auprès d'un administrateur.
+ Peut créer des bases de données dans le catalogue de données.
+ Peut accorder l'autorisation de créer une base de données à un autre utilisateur.
Les administrateurs de data lake peuvent enregistrer des sites Amazon S3 uniquement s'ils disposent des autorisations IAM pour le faire. Les politiques proposées aux administrateurs des lacs de données dans ce guide accordent ces autorisations. En outre, les administrateurs des lacs de données ne disposent pas des autorisations implicites leur permettant de supprimer des bases de données ou alter/drop des tables créées par d'autres. Ils peuvent toutefois s'octroyer l'autorisation de le faire.
Pour plus d'informations sur les administrateurs de data lake, consultez[Création d'un administrateur de lac de données](initial-lf-config.md#create-data-lake-admin).
**Créateurs de catalogues**
+ Disposez de toutes les autorisations de catalogue sur les catalogues qu'ils créent, d'autorisations sur les bases de données et les tables qu'ils créent dans le catalogue, et vous pouvez accorder aux autres principaux du même AWS compte l'autorisation de créer des bases de données et des tables dans le catalogue. Un créateur de catalogue qui dispose également de la politique `AWSLakeFormationCrossAccountManager` AWS gérée peut accorder des autorisations sur le catalogue à d'autres AWS comptes ou organisations.
Les administrateurs de data lake peuvent utiliser la console ou l'API Lake Formation pour désigner les créateurs de catalogues.
**Note**
Les créateurs de catalogues ne disposent pas implicitement d'autorisations sur les bases de données et les tables créées par d'autres utilisateurs dans le catalogue.
Pour plus d'informations sur la création de catalogues, consultez[Intégrer vos données dans AWS Glue Data Catalog](bring-your-data-overview.md).
**créateurs de bases de données**
+ Disposer de toutes les autorisations de base de données sur les bases de données qu'ils créent, d'autorisations sur les tables qu'ils créent dans la base de données et peuvent accorder aux autres principaux du même AWS compte l'autorisation de créer des tables dans la base de données. Un créateur de base de données qui dispose également de la politique `AWSLakeFormationCrossAccountManager` AWS gérée peut accorder des autorisations sur la base de données à d'autres AWS comptes ou organisations.
Les administrateurs de data lake peuvent utiliser la console ou l'API Lake Formation pour désigner les créateurs de bases de données.
**Note**
Les créateurs de base de données ne disposent pas implicitement d'autorisations sur les tables créées par d'autres utilisateurs dans la base de données.
Pour de plus amples informations, veuillez consulter [Création d’une base de données](creating-database.md).
**Créateurs de tables**
+ Disposent de toutes les autorisations sur les tables qu'ils créent.
+ Ils peuvent accorder des autorisations sur toutes les tables qu'ils créent aux principaux d'un même AWS compte.
+ Ils peuvent accorder des autorisations sur toutes les tables qu'ils créent à d'autres AWS comptes ou organisations s'ils disposent de la politique `AWSLakeFormationCrossAccountManager` AWS gérée.
+ Peut afficher les bases de données qui contiennent les tables qu'ils créent.
# Référence des autorisations de Lake Formation
Pour effectuer des AWS Lake Formation opérations, les directeurs ont besoin à la fois des autorisations Lake Formation et des autorisations Gestion des identités et des accès AWS (IAM). Vous accordez généralement des autorisations IAM à l'aide de politiques de contrôle d'accès *grossières*, comme décrit dans. [Vue d'ensemble des autorisations relatives à Lake Formation](lf-permissions-overview.md) Vous pouvez accorder des autorisations à Lake Formation à l'aide de la console, de l'API ou du AWS Command Line Interface (AWS CLI).
Pour savoir comment accorder ou révoquer les autorisations de Lake Formation, consultez [Octroi d'autorisations sur les ressources du catalogue de données](granting-catalog-permissions.md) et[Octroi d'autorisations de localisation des données](granting-location-permissions.md).
**Note**
Les exemples de cette section montrent comment accorder des autorisations aux principaux d'un même AWS compte. Pour des exemples de subventions entre comptes, voir[Partage de données entre comptes dans Lake Formation](cross-account-permissions.md).
## Permissions de Lake Formation par type de ressource
Voici les autorisations valides de Lake Formation disponibles pour chaque type de ressource :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/lf-permissions-reference.html)
**Topics**
+ [Permissions de Lake Formation par type de ressource](#lf-resource-permissions-summary)
+ [Lake Formation accorde et AWS CLI révoque des commandes](#perm-command-format)
+ [Autorisations Lake Formation](#lf-permissions)
## Lake Formation accorde et AWS CLI révoque des commandes
Chaque description d'autorisation présentée dans cette section inclut des exemples d'octroi de l'autorisation à l'aide d'une AWS CLI commande. Voici les synopsis de la Lake Formation **grant-permissions** et **revoke-permissions** AWS CLI des commandes.
```
grant-permissions
[--catalog-id ]
--principal
--resource
--permissions
[--permissions-with-grant-option ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
```
revoke-permissions
[--catalog-id ]
--principal
--resource
--permissions
[--permissions-with-grant-option ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
*Pour une description détaillée de ces commandes, voir [grant-permissions et [revoke-permissions](https://docs.aws.amazon.com/cli/latest/reference/lakeformation/revoke-permissions.html)](https://docs.aws.amazon.com/cli/latest/reference/lakeformation/grant-permissions.html) dans la référence des commandes.AWS CLI * Cette section fournit des informations supplémentaires sur `--principal` cette option.
La valeur de l'`--principal`option est l'une des suivantes :
+ Amazon Resource Name (ARN) pour un utilisateur ou un rôle Gestion des identités et des accès AWS (IAM)
+ ARN pour un utilisateur ou un groupe qui s'authentifie via un fournisseur SAML, tel que Microsoft Active Directory Federation Service (AD FS)
+ ARN pour un utilisateur ou un groupe Amazon Quick
+ Pour les autorisations entre comptes, un identifiant de AWS compte, un identifiant d'organisation ou un identifiant d'unité organisationnelle
+ Pour l'utilisateur ou le groupe IAM Identity Center, l'ARN de l'utilisateur ou du groupe IAM Identity Center.
Vous trouverez ci-dessous la syntaxe et des exemples pour tous les `--principal` types.
**Le principal est un utilisateur IAM**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::user/
```
Exemple :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1
```
**Le directeur est un rôle IAM**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::role/
```
Exemple :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:role/workflowrole
```
**Le principal est un utilisateur s'authentifiant via un fournisseur SAML**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::saml-provider/:user/
```
Exemples :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/idp1:user/datalake_user1
```
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/AthenaLakeFormationOkta:user/athena-user@example.com
```
**Le principal est un groupe s'authentifiant via un fournisseur SAML**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::saml-provider/:group/
```
Exemples :
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/idp1:group/data-scientists
```
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/AthenaLakeFormationOkta:group/my-group
```
**Le principal est un utilisateur d'Amazon Quick Enterprise Edition**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:::user//
```
Pour **, vous devez spécifier `default`.
Exemple :
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:us-east-1:111122223333:user/default/bi_user1
```
**Principal est un groupe Amazon Quick Enterprise Edition**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:::group//
```
Pour **, vous devez spécifier `default`.
Exemple :
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:us-east-1:111122223333:group/default/data_scientists
```
**Le principal est un AWS compte**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=
```
Exemple :
```
--principal DataLakePrincipalIdentifier=111122223333
```
**Le principal est une organisation**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations:::organization/
```
Exemple :
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations::111122223333:organization/o-abcdefghijkl
```
**Le directeur est une unité organisationnelle**
Syntaxe :
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations:::ou//
```
Exemple :
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations::111122223333:ou/o-abcdefghijkl/ou-ab00-cdefghij
```
**Le principal est un utilisateur ou un groupe d'identités IAM Identity Center**
Exemple : utilisateur
```
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::user/
```
Exemple : Groupe :
```
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::group/
```
**Le principal est un groupe IAM - `IAMAllowedPrincipals`**
Lake Formation attribue des `Super` autorisations sur toutes les bases de données et tables du catalogue de données à un groupe appelé `IAMAllowedPrincipals` par défaut. Si cette autorisation de groupe existe sur une base de données ou une table, tous les principaux de votre compte auront accès à la ressource par le biais des politiques principales IAM pour. AWS Glue Il assure une rétrocompatibilité lorsque vous commencez à utiliser les autorisations de Lake Formation pour sécuriser les ressources du catalogue de données qui étaient auparavant protégées par les politiques IAM pour AWS Glue.
Lorsque vous utilisez Lake Formation pour gérer les autorisations pour les ressources de votre catalogue de données, vous devez d'abord révoquer l'`IAMAllowedPrincipals`autorisation sur les ressources, ou activer les principes et les ressources en mode d'accès hybride pour que les autorisations de Lake Formation fonctionnent.
Exemple :
```
--principal DataLakePrincipalIdentifier=IAM_Allowed_Principals
```
**Le principal est un groupe IAM - `ALLIAMPrincipals`**
Lorsque vous autorisez un `ALLIAMPrincipals` groupe sur une ressource de catalogue de données, chaque principal du compte a accès à la ressource de catalogue de données à l'aide des autorisations Lake Formation et des autorisations IAM.
Exemple :
```
--principal DataLakePrincipalIdentifier=123456789012:IAMPrincipals
```
## Autorisations Lake Formation
Cette section contient les autorisations de Lake Formation disponibles que vous pouvez accorder aux directeurs.
### `ALTER`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| ALTER | DATABASE | glue:UpdateDatabase |
| ALTER | TABLE | glue:UpdateTable |
| ALTER | LF-Tag | lakeformation:UpdateLFTag |
Un directeur disposant de cette autorisation peut modifier les métadonnées d'une base de données ou d'une table dans le catalogue de données. Pour les tables, vous pouvez modifier le schéma des colonnes et ajouter des paramètres de colonne. Vous ne pouvez pas modifier les colonnes des données sous-jacentes vers lesquelles pointe une table de métadonnées.
Si la propriété modifiée est un emplacement enregistré auprès d'Amazon Simple Storage Service (Amazon S3), le principal doit disposer des autorisations de localisation des données sur le nouvel emplacement.
**Example**
L'exemple suivant accorde l'`ALTER`autorisation à l'utilisateur `datalake_user1` sur la base de données `retail` dans le AWS compte 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ALTER" --resource '{ "Database": {"Name":"retail"}}'
```
**Example**
L'exemple suivant accorde `ALTER` à l'utilisateur le droit d'`datalake_user1`accéder à la table `inventory` de la base de données`retail`.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ALTER" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
### `CREATE_DATABASE`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| CREATE\$1DATABASE | Catalogue de données | glue:CreateDatabase |
Un directeur disposant de cette autorisation peut créer une base de données de métadonnées ou un lien de ressource dans le catalogue de données. Le principal peut également créer des tables dans la base de données.
**Example**
L'exemple suivant octroie `CREATE_DATABASE` à l'utilisateur `datalake_user1` du AWS compte 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "CREATE_DATABASE" --resource '{ "Catalog": {}}'
```
Lorsqu'un principal crée une base de données dans le catalogue de données, aucune autorisation sur les données sous-jacentes n'est accordée. Les autorisations de métadonnées supplémentaires suivantes sont accordées (ainsi que la possibilité d'accorder ces autorisations à d'autres personnes) :
+ `CREATE_TABLE`dans la base de données
+ Base de données `ALTER`
+ Base de données `DROP`
Lors de la création d'une base de données, le principal peut éventuellement spécifier un emplacement Amazon S3. Selon que le principal dispose ou non d'autorisations de localisation des données, celles-ci `CREATE_DATABASE` peuvent ne pas être suffisantes pour créer des bases de données dans tous les cas. Il est important de garder à l'esprit les trois cas suivants.
| Créer un cas d'utilisation de base de données | Autorisations nécessaires |
| --- | --- |
| La propriété de localisation n'est pas spécifiée. | CREATE\$1DATABASEest suffisant. |
| La propriété de localisation est spécifiée, et l'emplacement n'est pas géré par Lake Formation (il n'est pas enregistré). | CREATE\$1DATABASEest suffisant. |
| La propriété de localisation est spécifiée, et l'emplacement est géré par Lake Formation (est enregistré). | CREATE\$1DATABASEest obligatoire, ainsi que les autorisations de localisation des données à l'emplacement spécifié. |
### `CREATE_TABLE`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| CREATE\$1TABLE | DATABASE | glue:CreateTable |
Un directeur disposant de cette autorisation peut créer une table de métadonnées ou un lien de ressource dans le catalogue de données de la base de données spécifiée.
**Example**
L'exemple suivant accorde à l'utilisateur l'`datalake_user1`autorisation de créer des tables dans la `retail` base de données sous le AWS compte 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1
--permissions "CREATE_TABLE" --resource '{ "Database": {"Name":"retail"}}'
```
Lorsqu'un directeur crée une table dans le catalogue de données, toutes les autorisations de Lake Formation sur la table sont accordées au principal, avec la possibilité d'accorder ces autorisations à d'autres personnes.
**Subventions entre comptes**
Si un compte propriétaire de base de données accorde une autorisation `CREATE_TABLE` à un compte destinataire et qu'un utilisateur du compte destinataire crée avec succès une table dans la base de données du compte propriétaire, les règles suivantes s'appliquent :
+ L'utilisateur et les administrateurs du lac de données du compte destinataire disposent de toutes les autorisations relatives à Lake Formation. Ils peuvent accorder des autorisations sur la table aux autres principaux de leur compte. Ils ne peuvent pas accorder d'autorisations aux principaux sur le compte du propriétaire ou sur tout autre compte.
+ Les administrateurs du lac de données du compte propriétaire peuvent accorder des autorisations sur la table aux autres principaux de leur compte.
**Autorisations de localisation des données**
Lorsque vous tentez de créer une table pointant vers un emplacement Amazon S3, selon que vous disposez ou non des autorisations de localisation des données, ces `CREATE_TABLE` autorisations peuvent ne pas être suffisantes pour créer une table. Il est important de garder à l'esprit les trois cas suivants.
| Création d'un cas d'utilisation d'une table | Autorisations nécessaires |
| --- | --- |
| L'emplacement spécifié n'est pas géré par Lake Formation (il n'est pas enregistré). | CREATE\$1TABLEest suffisant. |
| L'emplacement spécifié est géré par Lake Formation (il est enregistré), et la base de données qui le contient ne possède aucune propriété de localisation ou possède une propriété de localisation qui n'est pas un préfixe Amazon S3 de l'emplacement de la table. | CREATE\$1TABLEest obligatoire, ainsi que les autorisations de localisation des données à l'emplacement spécifié. |
| L'emplacement spécifié est géré par Lake Formation (il est enregistré), et la base de données contenant possède une propriété de localisation qui pointe vers un emplacement enregistré et qui est un préfixe Amazon S3 de l'emplacement de la table. | CREATE\$1TABLEest suffisant. |
### `DATA_LOCATION_ACCESS`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| DATA\$1LOCATION\$1ACCESS | Emplacement Amazon S3 | (Autorisations Amazon S3 sur l'emplacement, qui doivent être spécifiées par le rôle utilisé pour enregistrer l'emplacement.) |
Il s'agit de la seule autorisation de localisation des données. Un principal disposant de cette autorisation peut créer une base de données ou une table de métadonnées pointant vers l'emplacement Amazon S3 spécifié. L'emplacement doit être enregistré. Un directeur qui dispose d'autorisations de localisation des données sur un emplacement possède également des autorisations de localisation sur les emplacements des enfants.
**Example**
L'exemple suivant accorde des autorisations de localisation des données `s3://products/retail` à l'utilisateur du AWS compte `datalake_user1` 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DATA_LOCATION_ACCESS" --resource '{ "DataLocation": {"ResourceArn":"arn:aws:s3:::products/retail"}}'
```
`DATA_LOCATION_ACCESS`n'est pas nécessaire pour interroger ou mettre à jour les données sous-jacentes. Cette autorisation s'applique uniquement à la création de ressources de catalogue de données.
Pour plus d'informations sur les autorisations de localisation des données, consultez[Underlying data access control](access-control-underlying-data.md#data-location-permissions).
### `DELETE`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| DELETE | TABLE | (Aucune autorisation IAM supplémentaire n'est requise si l'emplacement est enregistré.) |
Un principal disposant de cette autorisation peut insérer, mettre à jour et lire les données sous-jacentes à l'emplacement Amazon S3 indiqué dans le tableau. Le directeur peut également consulter le tableau sur la console Lake Formation et récupérer des informations sur le tableau à l'aide de l'AWS GlueAPI.
**Example**
L'exemple suivant accorde l'`DELETE`autorisation à l'utilisateur `datalake_user1` sur la table de la base de données `inventory` dans le AWS compte `retail` 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DELETE" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Cette autorisation s'applique uniquement aux données d'Amazon S3, et non aux données d'autres magasins de données tels qu'Amazon Relational Database Service (Amazon RDS).
### `DESCRIBE`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| DESCRIBE | Lien vers les ressources du tableau Lien vers les ressources de la base | `glue:GetTable` `glue:GetDatabase` |
| DESCRIBE | DATABASE | glue:GetDatabase |
| DESCRIBE | TABLE | glue:GetTable |
| DESCRIBE | LF-Tag | `glue:GetTable` `glue:GetDatabase` `lakeformation:GetResourceLFTags` `lakeformation:ListLFTags` `lakeformation:GetLFTag` `lakeformation:SearchTablesByLFTags` `lakeformation:SearchDatabasesByLFTags` |
Un principal disposant de cette autorisation peut consulter la base de données, la table ou le lien de ressource spécifié. Aucune autre autorisation de catalogue de données n'est accordée implicitement, et aucune autorisation d'accès aux données n'est accordée implicitement. Les bases de données et les tables apparaissent dans les éditeurs de requêtes des services intégrés, mais aucune requête ne peut être effectuée à leur encontre à moins que d'autres autorisations de Lake Formation (par exemple,`SELECT`) ne soient accordées.
Par exemple, un utilisateur qui possède une `DESCRIBE` base de données peut voir la base de données et toutes les métadonnées de la base de données (description, emplacement, etc.). Toutefois, l'utilisateur ne peut pas savoir quelles tables contient la base de données et ne peut pas supprimer, modifier ou créer des tables dans la base de données. De même, un utilisateur qui possède `DESCRIBE` une table peut voir la table et ses métadonnées (description, schéma, emplacement, etc.), mais ne peut pas supprimer, modifier ou exécuter des requêtes sur la table.
Voici quelques règles supplémentaires pour `DESCRIBE` :
+ Si un utilisateur dispose d'autres autorisations Lake Formation sur une base de données, une table ou un lien de ressource, elles `DESCRIBE` sont implicitement accordées.
+ Si un utilisateur ne dispose `SELECT` que d'un sous-ensemble de colonnes pour un tableau (partiel`SELECT`), il est limité à l'affichage de ces colonnes.
+ Vous ne pouvez pas accorder d'autorisation `DESCRIBE` à un utilisateur qui a effectué une sélection partielle sur une table. À l'inverse, vous ne pouvez pas spécifier de listes d'inclusion ou d'exclusion de colonnes pour les `DESCRIBE` tables accordées sur.
**Example**
L'exemple suivant accorde l'`DESCRIBE`autorisation à l'utilisateur `datalake_user1` sur le lien de ressource de la table dans la base de données `inventory-link` dans le AWS compte `retail` 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DESCRIBE" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory-link"}}'
```
### `DROP`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| DROP | DATABASE | glue:DeleteDatabase |
| DROP | TABLE | glue:DeleteTable |
| DROP | LF-Tag | lakeformation:DeleteLFTag |
| DROP | Lien vers les ressources de la base Lien vers les ressources du tableau | `glue:DeleteDatabase` `glue:DeleteTable` |
Un principal disposant de cette autorisation peut supprimer une base de données, une table ou un lien de ressource dans le catalogue de données. Vous ne pouvez pas accorder l'autorisation DROP sur une base de données à un compte ou à une organisation externe.
**Avertissement**
La suppression d'une base de données entraîne la suppression de toutes les tables de la base de données.
**Example**
L'exemple suivant accorde l'`DROP`autorisation à l'utilisateur `datalake_user1` sur la base de données `retail` dans le AWS compte 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Database": {"Name":"retail"}}'
```
**Example**
L'exemple suivant accorde des `DROP` autorisations à l'utilisateur `datalake_user1` sur la table de `inventory` la base de données`retail`.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
**Example**
L'exemple suivant accorde `DROP` à l'utilisateur `datalake_user1` sur la table un lien de ressource `inventory-link` dans la base de données`retail`.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory-link"}}'
```
### `INSERT`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| INSERT | TABLE | (Aucune autorisation IAM supplémentaire n'est requise si l'emplacement est enregistré.) |
Un principal disposant de cette autorisation peut insérer, mettre à jour et lire les données sous-jacentes à l'emplacement Amazon S3 indiqué dans le tableau. Le directeur peut également consulter le tableau dans la console Lake Formation et récupérer des informations sur le tableau à l'aide de l'AWS GlueAPI.
**Example**
L'exemple suivant accorde l'`INSERT`autorisation à l'utilisateur `datalake_user1` sur la table de la base de données `inventory` dans le AWS compte `retail` 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "INSERT" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Cette autorisation s'applique uniquement aux données d'Amazon S3, et non aux données d'autres magasins de données tels qu'Amazon RDS.
### `SELECT`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| SELECT | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/lf-permissions-reference.html) | (Aucune autorisation IAM supplémentaire n'est requise si l'emplacement est enregistré.) |
Un directeur disposant de cette autorisation peut consulter une table dans le catalogue de données et interroger les données sous-jacentes dans Amazon S3 à l'emplacement spécifié par la table. Le directeur peut consulter le tableau dans la console Lake Formation et récupérer des informations sur le tableau à l'aide de l'AWS GlueAPI. Si le filtrage des colonnes a été appliqué lorsque cette autorisation a été accordée, le principal peut consulter les métadonnées uniquement pour les colonnes incluses et ne peut interroger les données qu'à partir des colonnes incluses.
**Note**
Il est de la responsabilité du service d'analyse intégré d'appliquer le filtrage des colonnes lors du traitement d'une requête.
**Example**
L'exemple suivant accorde l'`SELECT`autorisation à l'utilisateur `datalake_user1` sur la table de la base de données `inventory` dans le AWS compte `retail` 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Cette autorisation s'applique uniquement aux données d'Amazon S3, et non aux données d'autres magasins de données tels qu'Amazon RDS.
Vous pouvez filtrer (restreindre l'accès à) des colonnes spécifiques à l'aide d'une liste d'inclusion ou d'exclusion facultative. Une liste d'inclusion indique les colonnes accessibles. Une liste d'exclusion indique les colonnes inaccessibles. En l'absence de liste d'inclusion ou d'exclusion, toutes les colonnes du tableau sont accessibles.
Les résultats de `glue:GetTable` renvoient uniquement les colonnes que l'appelant est autorisé à consulter. Les services intégrés tels qu'Amazon Athena et Amazon Redshift respectent les listes d'inclusion et d'exclusion des colonnes.
**Example**
L'exemple suivant octroie une `SELECT` autorisation à l'utilisateur figurant `datalake_user1` sur la table `inventory` à l'aide d'une liste d'inclusion.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "TableWithColumns": {"DatabaseName":"retail", "Name":"inventory", "ColumnNames": ["prodcode","location","period","withdrawals"]}}'
```
**Example**
L'exemple suivant donne des autorisations `SELECT` sur la `inventory` table à l'aide d'une liste d'exclusion.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "TableWithColumns": {"DatabaseName":"retail", "Name":"inventory", "ColumnWildcard": {"ExcludedColumnNames": ["intkey", "prodcode"]}}}'
```
Les restrictions suivantes s'appliquent à l'`SELECT`autorisation :
+ Lors de l'octroi`SELECT`, vous ne pouvez pas inclure l'option d'octroi si le filtrage des colonnes est appliqué.
+ Vous ne pouvez pas restreindre le contrôle d'accès aux colonnes qui sont des clés de partition.
+ Un principal disposant de l'`SELECT`autorisation sur un sous-ensemble de colonnes d'une table ne peut pas obtenir l'`INSERT`autorisation `ALTER``DROP`,`DELETE`, ou sur cette table. De même, un principal disposant de l'`INSERT`autorisation `ALTER` `DROP``DELETE`,, ou sur une table ne peut pas `SELECT` obtenir l'autorisation de filtrage des colonnes.
L'`SELECT`autorisation apparaît toujours sur la page **Autorisations relatives aux données** de la console Lake Formation sous forme de ligne séparée. L'image suivante montre que cela `SELECT` est accordé aux utilisateurs `datalake_user2` et `datalake_user3` sur toutes les colonnes du `inventory` tableau.
![\[La page Autorisations relatives aux données comporte quatre lignes. Les première et troisième lignes répertorient le tableau des autorisations de suppression et d'insertion avec le type de ressource avec la ressource affichée sous forme d'inventaire, et les deuxième et quatrième lignes répertorient la colonne Autorisation de sélection avec type de ressource, avec la ressource indiquée sous la forme retail.inventory.*.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/data-permissions-dialog-select-cross.png)
### `Super`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| Super | DATABASE | glue:\$1Database\$1 |
| Super | TABLE | glue:\$1Table\$1, glue:\$1Partition\$1 |
Cette autorisation permet au principal d'effectuer toutes les opérations de Lake Formation prises en charge sur la base de données ou la table. Vous ne pouvez pas attribuer une `Super` base de données à un compte externe.
Cette autorisation peut coexister avec les autres autorisations de Lake Formation. Par exemple, vous pouvez accorder les `INSERT` autorisations `Super``SELECT`, et sur une table de métadonnées. Le principal peut ensuite effectuer toutes les opérations prises en charge sur la table. Lorsque vous révoquez`Super`, les `INSERT` autorisations `SELECT` et sont conservées et le principal ne peut effectuer que des opérations de sélection et d'insertion.
Au lieu de l'octroyer `Super` à un directeur individuel, vous pouvez l'accorder au groupe`IAMAllowedPrincipals`. Le `IAMAllowedPrincipals` groupe est créé automatiquement et inclut tous les utilisateurs et rôles IAM autorisés à accéder aux ressources de votre catalogue de données par vos politiques IAM. Lorsqu'il `Super` est accordé `IAMAllowedPrincipals` pour une ressource de catalogue de données, l'accès à la ressource est effectivement contrôlé uniquement par les politiques IAM.
Vous pouvez `Super` obtenir l'autorisation d'accéder automatiquement `IAMAllowedPrincipals` aux nouvelles ressources du catalogue en tirant parti des options de la page **Paramètres** de la console Lake Formation.
![\[La boîte de dialogue des paramètres du catalogue de données a pour sous-titre « Autorisations par défaut pour les bases de données et tables nouvellement créées » et comporte deux cases à cocher, décrites dans le texte.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/settings-page.png)
+ Pour l'accorder `Super` à `IAMAllowedPrincipals` toutes les nouvelles bases de données, sélectionnez **Utiliser uniquement le contrôle d'accès IAM pour les nouvelles bases** de données.
+ `IAMAllowedPrincipals`Pour l'accorder `Super` à toutes les nouvelles tables des nouvelles bases de données, sélectionnez **Utiliser uniquement le contrôle d'accès IAM pour les nouvelles tables des nouvelles bases de** données.
**Note**
Cette option entraîne la sélection par défaut de la case **Utiliser uniquement le contrôle d'accès IAM pour les nouvelles tables de cette base** de **données dans la boîte de dialogue Créer** une base de données. Il ne fait rien de plus que cela. C'est la case à cocher de la boîte **de dialogue Créer une base** de données qui permet d'accorder `Super` à`IAMAllowedPrincipals`.
Ces options de la page **Paramètres** sont activées par défaut. Pour plus d’informations, consultez les ressources suivantes :
+ [Modification des paramètres par défaut de votre lac de données](change-settings.md)
+ [Mise à niveau AWS Glue des autorisations de données vers le AWS Lake Formation modèle](upgrade-glue-lake-formation.md)
### `SUPER_USER`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| Super user | Catalog | glue:GetCatalog |
Vous ne pouvez accorder l'`Super user`autorisation qu'à des entités spécifiques sur les catalogues du catalogue de données par défaut. Vous ne pouvez pas accorder d'`Super user`autorisation sur le catalogue par défaut ou sur d'autres types de ressources tels que les bases de données et les tables, ou aux principaux de comptes externes. L'`Super user`autorisation d'autorisation permet au principal d'effectuer toutes les opérations de Lake Formation prises en charge sur les bases de données et les tables du catalogue accordé.
Avec cette `Super user` autorisation, le principal (bénéficiaire) est en mesure d'effectuer les actions suivantes sur les ressources (catalogues, bases de données et tables) du catalogue :
+ `CREATE_DATABASE`, `DESCRIBE` autorisations sur le catalogue.
+ `DROP`,`ALTER`,`CREATE_TABLE`, autorisations `DESCRIBE` (effectivement`SUPER`) sur toutes les bases de données du catalogue.
+ `DROP`,`ALTER`,`DESCRIBE`,, `SELECT``INSERT`, `DELETE` (effectivement`SUPER`) autorisations sur toutes les tables de toutes les bases de données du catalogue.
+ `All`autorisations (en fait SUPER) sur les catalogues du catalogue.
+ Autorisations accordables (possibilité d'accorder ces autorisations à d'autres principaux) sur tous les catalogues, bases de données et tables du catalogue.
Avec l'`Super user`autorisation sur une ressource du catalogue, le bénéficiaire n'est pas autorisé à effectuer ou à déléguer `ALTER` des `DROP` actions sur le catalogue.
### `ASSOCIATE`
| Autorisations | Accordé sur cette ressource | Le bénéficiaire a également besoin |
| --- | --- | --- |
| ASSOCIATE | LF-Tag | `glue:GetDatabase` `glue:GetTable` `lakeformation:AddLFTagsToResource"` `lakeformation:RemoveLFTagsFromResource"` `lakeformation:GetResourceLFTags` `lakeformation:ListLFTags` `lakeformation:GetLFTag` `lakeformation:SearchTablesByLFTags` `lakeformation:SearchDatabasesByLFTags` |
Un directeur disposant de cette autorisation sur une balise LF peut attribuer la balise LF à une ressource de catalogue de données. Accorder `ASSOCIATE` implicitement des subventions`DESCRIBE`.
**Example**
Cet exemple accorde à l'utilisateur `datalake_user1` l'`ASSOCIATE`autorisation d'utiliser le tag LF avec la clé. `module` Il autorise l'affichage et l'attribution de toutes les valeurs pour cette clé, comme indiqué par l'astérisque (\$1).
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ASSOCIATE" --resource '{ "LFTag": {"CatalogId":"111122223333","TagKey":"module","TagValues":["*"]}}'
```
# Intégration d'IAM Identity Center
Vous pouvez ainsi vous connecter à des fournisseurs d'identité (IdPs) et gérer de manière centralisée l'accès des utilisateurs et des groupes à travers les services AWS d'analyse. AWS IAM Identity Center Vous pouvez intégrer des fournisseurs d’identité tels qu’Okta, Ping et Microsoft Entra ID (anciennement Azure Active Directory) à IAM Identity Center pour que les utilisateurs de votre organisation puissent accéder aux données via une expérience d’authentification unique. IAM Identity Center prend également en charge la connexion à d’autres fournisseurs d’identité tiers.
Pour plus d'informations, reportez-vous à la section [Fournisseurs d'identité pris en charge](https://docs.aws.amazon.com/singlesignon/latest/userguide/supported-idps.html) dans le Guide de AWS IAM Identity Center l'utilisateur.
Vous pouvez AWS Lake Formation le configurer en tant qu'application activée dans IAM Identity Center, et les administrateurs de data lake peuvent accorder des autorisations détaillées aux utilisateurs et aux groupes autorisés sur les ressources. AWS Glue Data Catalog
Les utilisateurs de votre organisation peuvent se connecter à n'importe quelle application compatible avec Identity Center en utilisant le fournisseur d'identité de votre organisation et interroger des ensembles de données en appliquant les autorisations de Lake Formation. Grâce à cette intégration, vous pouvez gérer l'accès aux AWS services sans créer plusieurs rôles IAM.
[La propagation fiable des identités](https://docs.aws.amazon.com//singlesignon/latest/userguide/trustedidentitypropagation-overview.html) est une AWS IAM Identity Center fonctionnalité que les administrateurs de Connected Services AWS peuvent utiliser pour accorder et auditer l'accès aux données de service. L’accès à ces données est basé sur les attributs utilisateur tels que les associations de groupe. La mise en place d'une propagation d'identité sécurisée nécessite une collaboration entre les administrateurs de Connected Services AWS et les administrateurs d'IAM Identity Center. Pour plus d’informations, consultez [Prérequis et considérations](https://docs.aws.amazon.com//singlesignon/latest/userguide/trustedidentitypropagation-overall-prerequisites.html).
Pour connaître les limitations, veuillez consulter [Limites de l'intégration d'IAM Identity Center](identity-center-lf-notes.md).
**Topics**
+ [Conditions préalables à l'intégration d'IAM Identity Center à Lake Formation](prerequisites-identity-center.md)
+ [Connecter Lake Formation à l'IAM Identity Center](connect-lf-identity-center.md)
+ [Mise à jour de l'intégration d'IAM Identity Center](update-lf-identity-center-connection.md)
+ [Suppression d'une connexion Lake Formation avec IAM Identity Center](delete-lf-identity-center-connection.md)
+ [Octroi d'autorisations aux utilisateurs et aux groupes](grant-permissions-sso.md)
+ [Intégration du contexte utilisateur d'IAM Identity Center dans les journaux CloudTrail](identity-center-ct-logs.md)
# Conditions préalables à l'intégration d'IAM Identity Center à Lake Formation
Les conditions préalables à l'intégration d'IAM Identity Center à Lake Formation sont les suivantes.
1. Activer le centre d'identité IAM : l'activation d'IAM Identity Center est une condition préalable à la prise en charge de l'authentification et de la propagation des identités.
1. Choisissez votre source d'identité : après avoir activé IAM Identity Center, vous devez disposer d'un fournisseur d'identité pour gérer les utilisateurs et les groupes. Vous pouvez utiliser le répertoire intégré Identity Center comme source d'identité ou utiliser un IdP externe, tel que Microsoft Entra ID ou Okta.
Pour plus d'informations, voir [Gérer votre source d'identité](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source.html) et [Se connecter à un fournisseur d'identité externe](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-idp.html) dans le guide de AWS IAM Identity Center l'utilisateur.
1. Créer un rôle IAM — Le rôle qui crée la connexion IAM Identity Center nécessite des autorisations pour créer et modifier la configuration de l'application dans Lake Formation et IAM Identity Center, conformément à la politique en ligne suivante.
Vous devez ajouter des autorisations conformément aux meilleures pratiques IAM. Les autorisations spécifiques sont détaillées dans les procédures qui suivent. Pour plus d'informations, consultez [Getting Started with IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/get-started-enable-identity-center.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:CreateLakeFormationIdentityCenterConfiguration",
"sso:CreateApplication",
"sso:PutApplicationAssignmentConfiguration",
"sso:PutApplicationAuthenticationMethod",
"sso:PutApplicationGrant",
"sso:PutApplicationAccessScope"
],
"Resource": [
"*"
]
}
]
}
```
------
Si vous partagez des ressources du catalogue de données avec des organisations externes Comptes AWS ou avec des organisations, vous devez disposer des autorisations AWS Resource Access Manager (AWS RAM) pour créer des partages de ressources. Pour plus d'informations sur les autorisations requises pour partager des ressources, consultez la section [Conditions requises pour le partage de données entre comptes](cross-account-prereqs.md).
Les politiques intégrées suivantes contiennent les autorisations spécifiques requises pour afficher, mettre à jour et supprimer les propriétés de l'intégration de Lake Formation à IAM Identity Center.
+ Utilisez la politique intégrée suivante pour autoriser un rôle IAM à visualiser une intégration de Lake Formation avec IAM Identity Center.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:DescribeLakeFormationIdentityCenterConfiguration",
"sso:DescribeApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Utilisez la politique intégrée suivante pour autoriser un rôle IAM à mettre à jour une intégration de Lake Formation avec IAM Identity Center. La politique inclut également les autorisations facultatives requises pour partager des ressources avec des comptes externes.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:UpdateLakeFormationIdentityCenterConfiguration",
"lakeformation:DescribeLakeFormationIdentityCenterConfiguration",
"sso:DescribeApplication",
"sso:UpdateApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Utilisez la politique intégrée suivante pour autoriser un rôle IAM à supprimer une intégration de Lake Formation avec IAM Identity Center.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:DeleteLakeFormationIdentityCenterConfiguration",
"sso:DeleteApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Pour les autorisations IAM requises pour accorder ou révoquer des autorisations de lac de données pour les utilisateurs et les groupes IAM Identity Center, voir. [Autorisations IAM requises pour accorder ou révoquer les autorisations de Lake Formation](required-permissions-for-grant.md)
*Description des autorisations*
+ `lakeformation:CreateLakeFormationIdentityCenterConfiguration`— Crée la configuration iDC de Lake Formation.
+ `lakeformation:DescribeLakeFormationIdentityCenterConfiguration`— Décrit une configuration iDC existante.
+ `lakeformation:DeleteLakeFormationIdentityCenterConfiguration`— Permet de supprimer une configuration iDC de Lake Formation existante.
+ `lakeformation:UpdateLakeFormationIdentityCenterConfiguration`— Utilisé pour modifier la configuration d'une Lake Formation existante.
+ `sso:CreateApplication` : sert à créer une application IAM Identity Center.
+ `sso:DeleteApplication` : sert à supprimer une application IAM Identity Center.
+ `sso:UpdateApplication` : sert à mettre à jour une application IAM Identity Center.
+ `sso:PutApplicationGrant` : sert à modifier les informations relatives à l’émetteur de jetons approuvé.
+ `sso:PutApplicationAuthenticationMethod`— Accorde un accès d'authentification à Lake Formation.
+ `sso:GetApplicationGrant` : sert à répertorier les informations relatives à l’émetteur de jetons approuvé.
+ `sso:DeleteApplicationGrant` : supprime les informations relatives à l’émetteur de jetons approuvé.
+ `sso:PutApplicationAccessScope`— Ajoute ou met à jour la liste des cibles autorisées pour une étendue d'accès à l'IAM Identity Center pour une application.
+ `sso:PutApplicationAssignmentConfiguration`— Utilisé pour configurer la manière dont les utilisateurs accèdent à une application.
# Connecter Lake Formation à l'IAM Identity Center
Avant de pouvoir utiliser IAM Identity Center pour gérer les identités afin d'accorder l'accès aux ressources du catalogue de données à l'aide de Lake Formation, vous devez suivre les étapes suivantes. Vous pouvez créer l'intégration IAM Identity Center à l'aide de la console Lake Formation ou AWS CLI.
------
#### [ AWS Management Console ]
**Pour connecter Lake Formation à l'IAM Identity Center**
1. Connectez-vous à la AWS Management Console console Lake Formation et ouvrez-la à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans le volet de navigation de gauche, sélectionnez **Intégration à IAM Identity Center**.
![\[Écran d'intégration d'IAM Identity Center avec Identity Center ARN.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/identity-center-integ.png)
1. (Facultatif) Entrez une ou plusieurs organisations IDs ou unités and/or organisationnelles valides Compte AWS IDs IDs pour autoriser les comptes externes à accéder aux ressources du catalogue de données. Lorsque des utilisateurs ou des groupes d'IAM Identity Center tentent d'accéder aux ressources du catalogue de données géré par Lake Formation, Lake Formation assume un rôle IAM pour autoriser l'accès aux métadonnées. Si le rôle IAM appartient à un compte externe qui n'a pas de politique de AWS Glue ressources ni de partage de AWS RAM ressources, les utilisateurs et les groupes de l'IAM Identity Center ne pourront pas accéder à la ressource même s'ils disposent des autorisations de Lake Formation.
Lake Formation utilise le service AWS Resource Access Manager (AWS RAM) pour partager la ressource avec des comptes et des organisations externes. AWS RAM envoie une invitation au compte du bénéficiaire pour qu'il accepte ou rejette le partage des ressources.
Pour de plus amples informations, veuillez consulter [Acceptation d'une invitation de partage de ressources de AWS RAM](accepting-ram-invite.md).
**Note**
Lake Formation permet aux rôles IAM issus de comptes externes d'agir en tant que rôles de support au nom des utilisateurs et des groupes d'IAM Identity Center pour accéder aux ressources du catalogue de données, mais les autorisations ne peuvent être accordées que sur les ressources du catalogue de données du compte propriétaire. Si vous essayez d'accorder des autorisations aux utilisateurs et aux groupes d'IAM Identity Center sur les ressources du catalogue de données d'un compte externe, Lake Formation génère le message d'erreur suivant : « Les autorisations entre comptes ne sont pas prises en charge pour le principal ».
1. (Facultatif) Sur l'écran **d'intégration ARNs de Create Lake Formation**, spécifiez les applications tierces qui peuvent accéder aux données des sites Amazon S3 enregistrés auprès de Lake Formation. Lake Formation fournit des informations d'identification temporaires limitées sous forme de AWS STS jetons aux sites Amazon S3 enregistrés en fonction des autorisations effectives, afin que les applications autorisées puissent accéder aux données pour le compte des utilisateurs.
1. (Facultatif) Sur l'écran d'**intégration de Create Lake Formation**, cochez la case Amazon Redshift Connect dans Trusted Identity Propagation pour activer la découverte des autorisations fédérées par Amazon Redshift via IDC. Lake Formation propage l'identité vers l'aval en fonction des autorisations effectives, afin que les applications autorisées puissent accéder aux données au nom des utilisateurs.
1. Sélectionnez **Soumettre**.
Une fois que l'administrateur de Lake Formation a terminé les étapes et créé l'intégration, les propriétés de l'IAM Identity Center apparaissent dans la console Lake Formation. L'exécution de ces tâches fait de Lake Formation une application compatible avec IAM Identity Center. Les propriétés de la console incluent l’état de l’intégration. L'état de l'intégration indique `Success` quand elle est terminée. Ce statut indique si la configuration du centre d'identité IAM est terminée.
------
#### [ AWS CLI ]
+ L'exemple suivant montre comment créer une intégration de Lake Formation avec IAM Identity Center. Vous pouvez également spécifier le `Status` (`ENABLED`,`DISABLED`) des applications.
```
aws lakeformation create-lake-formation-identity-center-configuration \
--catalog-id <123456789012> \
--instance-arn \
--share-recipients '[{"DataLakePrincipalIdentifier": "<123456789012>"},
{"DataLakePrincipalIdentifier": "<555555555555>"}]' \
--external-filtering '{"AuthorizedTargets": ["", ""], "Status": "ENABLED"}'
```
+ L'exemple suivant montre comment visualiser une intégration de Lake Formation avec IAM Identity Center.
```
aws lakeformation describe-lake-formation-identity-center-configuration
--catalog-id <123456789012>
```
+ L'exemple suivant montre comment activer `Redshift:Connect` l'autorisation. L'autorisation peut être ACTIVÉE ou DÉSACTIVÉE.
```
aws lakeformation create-lake-formation-identity-center-configuration \
--instance-arn \
--service-integrations '[{
"Redshift": [{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}]
}]'
```
+ Utilisez la `describe-lake-formation-identity-center-configuration` commande pour décrire l'application Lake Formation Identity Center. `Redshift:Connect`l'intégration des services est essentielle pour la propagation de l'identité iDC entre services et entre clusters :
```
aws lakeformation describe-lake-formation-identity-center-configuration --catalog-id <123456789012>
```
Réponse :
```
{
"CatalogId": "CATALOG ID",
"InstanceArn": "INSTANCE ARN",
"ApplicationArn": "APPLICATION ARN",
"ShareRecipients": [],
"ServiceIntegrations": [
{
"Redshift": [
{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}
]
}
]
}
```
------
## Utilisation d'IAM Identity Center sur plusieurs Régions AWS
Lake Formation prend en charge l'IAM Identity Center à plusieurs Régions AWS reprises. Vous pouvez étendre IAM Identity Center de votre région principale Région AWS à d'autres régions pour améliorer les performances grâce à la proximité des utilisateurs et à la fiabilité. Lorsqu'une nouvelle région est ajoutée dans IAM Identity Center, vous pouvez créer des applications Lake Formation Identity Center dans la nouvelle région sans répliquer les identités de la région principale. Pour plus de détails sur les premiers pas avec IAM Identity Center dans plusieurs régions, consultez la section [Multi-Region IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/multi-region-iam-identity-center.html) dans le guide de l'utilisateur d'*IAM Identity* Center.
# Mise à jour de l'intégration d'IAM Identity Center
Après avoir créé la connexion, vous pouvez ajouter des applications tierces pour l'intégration d'IAM Identity Center afin de les intégrer à Lake Formation et d'accéder aux données Amazon S3 pour le compte des utilisateurs. Vous pouvez également supprimer des applications existantes de l'intégration d'IAM Identity Center. Vous pouvez ajouter ou supprimer des applications à l'aide de la console Lake Formation et en utilisant [UpdateLakeFormationIdentityCenterConfiguration](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_UpdateLakeFormationIdentityCenterConfiguration.html)Operation. AWS CLI
**Note**
Après avoir créé l'intégration IAM Identity Center, vous ne pouvez pas mettre à jour l'instance`ARN`.
------
#### [ AWS Management Console ]
**Pour mettre à jour une connexion IAM Identity Center existante avec Lake Formation**
1. Connectez-vous à la AWS Management Console console Lake Formation et ouvrez-la à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans le volet de navigation de gauche, sélectionnez **Intégration à IAM Identity Center**.
1. Sélectionnez **Ajouter** sur la page d'**intégration d'IAM Identity Center**.
1. Entrez une ou plusieurs organisations IDs ou unités and/or organisationnelles valides Compte AWS IDs IDs pour autoriser les comptes externes à accéder aux ressources du catalogue de données.
1. Sur l'écran **Ajouter des applications**, entrez l'application IDs des applications tierces que vous souhaitez intégrer à Lake Formation.
1. Sélectionnez **Ajouter**.
1. (Facultatif) Sur la page d'**intégration d'IAM Identity Center**, vous pouvez soit activer la propagation d'identité sécurisée pour Amazon Redshift Connect, soit la désactiver. Lake Formation propage l'identité vers l'aval en fonction des autorisations effectives, afin que les applications autorisées puissent accéder aux données au nom des utilisateurs.
------
#### [ AWS CLI ]
Vous pouvez ajouter ou supprimer des applications tierces pour l'intégration d'IAM Identity Center en exécutant la AWS CLI commande suivante. Lorsque vous définissez l'état du filtrage externe sur`ENABLED`, cela permet à l'IAM Identity Center de fournir une gestion des identités permettant aux applications tierces d'accéder aux données gérées par Lake Formation. Vous pouvez également activer ou désactiver l'intégration d'IAM Identity Center en définissant le statut de l'application.
```
aws lakeformation update-lake-formation-identity-center-configuration \
--external-filtering '{"AuthorizedTargets": ["", ""], "Status": "ENABLED"}'\
--share-recipients '[{"DataLakePrincipalIdentifier": "<444455556666>"}
{"DataLakePrincipalIdentifier": "<777788889999>"}]' \
--application-status ENABLED
```
Si vous avez une application LF IDC existante, mais que vous souhaitez ajouter l'`Redshift:Connect`autorisation, vous pouvez utiliser ce qui suit pour mettre à jour votre application Lake Formation IDC. L'autorisation peut être ACTIVÉE ou DÉSACTIVÉE.
```
aws lakeformation update-lake-formation-identity-center-configuration \
--service-integrations '[{
"Redshift": [{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}]
}]'
```
------
# Suppression d'une connexion Lake Formation avec IAM Identity Center
Si vous souhaitez supprimer une intégration IAM Identity Center existante, vous pouvez le faire à l'aide de la console Lake Formation ou d'une [DeleteLakeFormationIdentityCenterConfiguration](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_DeleteLakeFormationIdentityCenterConfiguration.html)opération. AWS CLI
------
#### [ AWS Management Console ]
**Pour supprimer une connexion IAM Identity Center existante avec Lake Formation**
1. Connectez-vous à la AWS Management Console console Lake Formation et ouvrez-la à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans le volet de navigation de gauche, sélectionnez **Intégration à IAM Identity Center**.
1. Sélectionnez **Supprimer** sur la page d'**intégration d'IAM Identity Center**.
1. Sur l'écran **Confirmer l'intégration**, confirmez l'action, puis sélectionnez **Supprimer**.
------
#### [ AWS CLI ]
Vous pouvez supprimer l'intégration d'IAM Identity Center en exécutant la AWS CLI commande suivante.
```
aws lakeformation delete-lake-formation-identity-center-configuration \
--catalog-id <123456789012>
```
------
# Octroi d'autorisations aux utilisateurs et aux groupes
L'administrateur de votre lac de données peut accorder des autorisations aux utilisateurs et aux groupes d'IAM Identity Center sur les ressources du catalogue de données (bases de données, tables et vues) afin de faciliter l'accès aux données. Pour accorder ou révoquer des autorisations de lac de données, le concédant a besoin d'autorisations pour les actions suivantes de l'IAM Identity Center.
+ [DescribeUser](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_DescribeUser.html)
+ [DescribeGroup](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_DescribeGroup.html)
+ [DescribeInstance](https://docs.aws.amazon.com/singlesignon/latest/APIReference/API_DescribeInstance.html)
Vous pouvez accorder des autorisations à l'aide de la console Lake Formation, de l'API ou du AWS CLI.
Pour plus d'informations sur l'octroi d'autorisations, consultez[Octroi d'autorisations sur les ressources du catalogue de données](granting-catalog-permissions.md).
**Note**
Vous ne pouvez accorder des autorisations que sur les ressources de votre compte. Pour attribuer des autorisations en cascade aux utilisateurs et aux groupes sur les ressources partagées avec vous, vous devez utiliser AWS RAM des partages de ressources.
------
#### [ AWS Management Console ]
**Pour accorder des autorisations aux utilisateurs et aux groupes**
1. Connectez-vous à la AWS Management Console console Lake Formation et ouvrez-la à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Sélectionnez **Autorisations du lac de données** sous **Autorisations** dans la console Lake Formation.
1. Sélectionnez **Grant**.
1. Sur la page **Accorder les autorisations du lac de données**, sélectionnez Utilisateurs et groupes **IAM Identity Center**.
1. Sélectionnez **Ajouter** pour choisir les utilisateurs et les groupes auxquels accorder des autorisations.
![\[Écran d'octroi d'autorisations pour les lacs de données avec les utilisateurs et les groupes IAM Identity Center sélectionnés.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/identity-center-grant-perm.png)
1. Sur l'écran **Attribuer des utilisateurs et des groupes**, choisissez les and/or groupes d'utilisateurs auxquels vous accordez des autorisations.
Sélectionnez **Attribuer**.
![\[Écran d'octroi d'autorisations pour les lacs de données avec les utilisateurs et les groupes IAM Identity Center sélectionnés.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/identity-center-assign-users-groups.png)
1. Ensuite, choisissez la méthode d'octroi des autorisations.
Pour obtenir des instructions sur l'octroi d'autorisations à l'aide de la méthode des ressources nommées, consultez[Octroi d'autorisations de données à l'aide de la méthode de ressource nommée](granting-cat-perms-named-resource.md).
Pour obtenir des instructions sur l'octroi d'autorisations à l'aide de balises LF, consultez. [Octroi d'autorisations de data lake à l'aide de la méthode LF-TBAC](granting-catalog-perms-TBAC.md)
1. Choisissez les ressources du catalogue de données pour lesquelles vous souhaitez accorder des autorisations.
1. Choisissez les autorisations de catalogue de données à accorder.
1. Sélectionnez **Grant**.
------
#### [ AWS CLI ]
L'exemple suivant montre comment accorder l'`SELECT`autorisation utilisateur d'IAM Identity Center sur une table.
```
aws lakeformation grant-permissions \
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::user/ \
--permissions "SELECT" \
--resource '{ "Table": { "DatabaseName": "retail", "TableWildcard": {} } }'
```
Pour effectuer une récupération `UserId` depuis IAM Identity Center, voir le [GetUserId](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_GetUserId.html)fonctionnement dans le manuel de référence de l'API IAM Identity Center.
------
# Intégration du contexte utilisateur d'IAM Identity Center dans les journaux CloudTrail
Lake Formation utilise la fonctionnalité de distribution [automatique d'informations d'identification](using-cred-vending.md) pour fournir un accès temporaire aux données Amazon S3. Par défaut, lorsqu'un utilisateur de l'IAM Identity Center soumet une requête à un service d'analyse intégré, les CloudTrail journaux incluent uniquement le rôle IAM assumé par le service pour fournir un accès à court terme. Si vous utilisez un rôle défini par l'utilisateur pour enregistrer l'emplacement des données Amazon S3 auprès de Lake Formation, vous pouvez choisir d'inclure le contexte de l'utilisateur IAM Identity Center dans les CloudTrail événements, puis de suivre les utilisateurs qui accèdent à vos ressources.
**Important**
Pour inclure les demandes d'API Amazon S3 au niveau de l'objet dans le CloudTrail, vous devez activer la journalisation des CloudTrail événements pour le compartiment et les objets Amazon S3. Pour plus d'informations, consultez la section [Activation de la journalisation des CloudTrail événements pour les buckets et les objets Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-cloudtrail-logging-for-s3.html) dans le guide de l'utilisateur Amazon S3.
**Pour activer l'audit des distributeurs automatiques d'informations d'identification sur les sites des lacs de données enregistrés avec des rôles définis par l'utilisateur**
1. Connectez-vous à la console Lake Formation à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans le volet de navigation de gauche, développez **Administration**, puis sélectionnez **Paramètres du catalogue de données**.
1. Sous **Audit amélioré**, choisissez **Propager le contexte fourni**.
1. Choisissez **Enregistrer**.
Vous pouvez également activer l'option d'audit améliorée en définissant l'`Parameters`attribut dans l'[PutDataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_PutDataLakeSettings.html)opération. Par défaut, la valeur du `SET_CONTEXT"` paramètre est définie sur « true ».
```
{
"DataLakeSettings": {
"Parameters": {"SET_CONTEXT": "true"},
}
}
```
Ce qui suit est un extrait d'un CloudTrail événement avec l'option d'audit améliorée. Ce journal inclut à la fois le contexte de session de l'utilisateur IAM Identity Center et le rôle IAM défini par l'utilisateur assumé par Lake Formation pour accéder à l'emplacement des données Amazon S3. Consultez le `onBehalfOf` paramètre dans l'extrait suivant.
```
{
"eventVersion":"1.09",
"userIdentity":{
"type":"AssumedRole",
"principalId":"AROAW7F7MOX4OYE6FLIFN:access-grants-e653760c-4e8b-44fd-94d9-309e035b75ab",
"arn":"arn:aws:sts::123456789012:assumed-role/accessGrantsTestRole/access-grants-e653760c-4e8b-44fd-94d9-309e035b75ab",
"accountId":"123456789012",
"accessKeyId":"ASIAW7F7MOX4CQLD4JIZN",
"sessionContext":{
"sessionIssuer":{
"type":"Role",
"principalId":"AROAW7F7MOX4OYE6FLIFN",
"arn":"arn:aws:iam::123456789012:role/accessGrantsTestRole",
"accountId":"123456789012",
"userName":"accessGrantsTestRole"
},
"attributes":{
"creationDate":"2023-08-09T17:24:02Z",
"mfaAuthenticated":"false"
}
},
"onBehalfOf":{
"userId": "",
"identityStoreArn": "arn:aws:identitystore::"
}
},
"eventTime":"2023-08-09T17:25:43Z",
"eventSource":"s3.amazonaws.com",
"eventName":"GetObject",
....
```
# Ajouter un emplacement Amazon S3 à votre lac de données
Pour ajouter un emplacement de données en tant que stockage dans votre lac de données, vous *devez enregistrer* l'emplacement (**emplacement du lac de données**) auprès de AWS Lake Formation. Vous pouvez ensuite utiliser les autorisations de Lake Formation pour un contrôle d'accès précis aux AWS Glue Data Catalog objets pointant vers cet emplacement et aux données sous-jacentes de cet emplacement.
Lake Formation permet également d'enregistrer un emplacement de données en mode d'accès hybride et vous offre la flexibilité d'activer de manière sélective les autorisations Lake Formation pour les bases de données et les tables de votre catalogue de données. Avec le mode d'accès hybride, vous disposez d'un chemin incrémentiel qui vous permet de définir les autorisations de Lake Formation pour un ensemble spécifique d'utilisateurs sans interrompre les politiques d'autorisation des autres utilisateurs ou charges de travail existants.
Pour plus d'informations sur la configuration du mode d'accès hybride, voir [Mode d'accès hybride](hybrid-access-mode.md)
Lorsque vous enregistrez un emplacement, ce chemin Amazon S3 et tous les dossiers situés sous ce chemin sont enregistrés.
Supposons, par exemple, que vous disposiez d'une organisation des chemins Amazon S3 telle que la suivante :
`/mybucket/accounting/sales/`
Si vous vous inscrivez`S3://mybucket/accounting`, le `sales` dossier est également enregistré et placé sous Gestion de Lake Formation.
Pour plus d'informations sur l'enregistrement des points de vente, consultez[Underlying data access control](access-control-underlying-data.md#underlying-data-access-control).
**Note**
Les autorisations Lake Formation sont recommandées pour les données structurées (organisées dans des tableaux avec des lignes et des colonnes). Si vos données contiennent des données non structurées basées sur des objets, pensez à utiliser les autorisations d'accès Amazon S3 pour gérer l'accès aux données.
**Topics**
+ [Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md)
+ [Enregistrement d'un emplacement Amazon S3](register-location.md)
+ [Enregistrement d'un emplacement Amazon S3 chiffré](register-encrypted.md)
+ [Enregistrement d'un emplacement Amazon S3 sur un autre AWS compte](register-cross-account.md)
+ [Enregistrement d'un emplacement Amazon S3 chiffré sur plusieurs AWS comptes](register-cross-encrypted.md)
+ [Annulation de l'enregistrement d'un site Amazon S3](unregister-location.md)
# Exigences relatives aux rôles utilisés pour enregistrer des sites
Vous devez spécifier un rôle Gestion des identités et des accès AWS (IAM) lorsque vous enregistrez un emplacement Amazon Simple Storage Service (Amazon S3). AWS Lake Formation assume ce rôle lors de l'accès aux données à cet emplacement.
Vous pouvez utiliser l'un des types de rôles suivants pour enregistrer un emplacement :
+ Le rôle lié au service Lake Formation. Ce rôle accorde les autorisations requises sur l'emplacement. L'utilisation de ce rôle est le moyen le plus simple d'enregistrer l'emplacement. Pour plus d’informations, consultez [Utilisation de rôles liés à un service pour Lake Formation](service-linked-roles.md) et [Limitations des rôles liés aux services](service-linked-role-limitations.md).
+ Rôle défini par l'utilisateur. Utilisez un rôle défini par l'utilisateur lorsque vous devez accorder plus d'autorisations que le rôle lié à un service n'en fournit.
Vous devez utiliser un rôle défini par l'utilisateur dans les cas suivants :
+ Lors de l'enregistrement d'une position dans un autre compte.
Pour plus d’informations, consultez [Enregistrement d'un emplacement Amazon S3 sur un autre AWS compte](register-cross-account.md) et [Enregistrement d'un emplacement Amazon S3 chiffré sur plusieurs AWS comptes](register-cross-encrypted.md).
+ Si vous avez utilisé une AWS clé CMK gérée (`aws/s3`) pour chiffrer l'emplacement Amazon S3.
Pour de plus amples informations, veuillez consulter [Enregistrement d'un emplacement Amazon S3 chiffré](register-encrypted.md).
+ Si vous prévoyez d'accéder à l'emplacement via Amazon EMR.
Si vous avez déjà enregistré un emplacement avec le rôle lié au service et que vous souhaitez commencer à y accéder avec Amazon EMR, vous devez annuler l'enregistrement du point de vente et le réenregistrer avec un rôle défini par l'utilisateur. Pour de plus amples informations, veuillez consulter [Annulation de l'enregistrement d'un site Amazon S3](unregister-location.md).
# Utilisation de rôles liés à un service pour Lake Formation
AWS Lake Formation utilise un rôle Gestion des identités et des accès AWS lié à un *service* (IAM). Un rôle lié à un service est un type unique de rôle IAM directement lié à Lake Formation. Le rôle lié au service est prédéfini par Lake Formation et inclut toutes les autorisations dont le service a besoin pour appeler d'autres AWS services en votre nom.
Un rôle lié à un service facilite la configuration de Lake Formation, car il n'est pas nécessaire de créer un rôle et d'ajouter manuellement les autorisations nécessaires. Lake Formation définit les autorisations associées à son rôle lié aux services et, sauf indication contraire, seule Lake Formation peut assumer ses rôles. Les autorisations définies comprennent la politique d’approbation et la politique d’autorisation. De plus, cette politique d’autorisation ne peut pas être attachée à une autre entité IAM.
Ce rôle lié à un service fait confiance aux services suivants pour assumer le rôle :
+ `lakeformation.amazonaws.com`
Lorsque vous utilisez un rôle lié à un service dans le compte A pour enregistrer un emplacement Amazon S3 appartenant au compte B, la politique de compartiment Amazon S3 (une politique basée sur les ressources) du compte B doit accorder des autorisations d'accès au rôle lié au service dans le compte A.
Pour plus d'informations sur l'utilisation d'un rôle lié à un service pour enregistrer un emplacement de données, consultez. [Limitations des rôles liés aux services](service-linked-role-limitations.md)
**Note**
Les politiques de contrôle des services (SCPs) n'affectent pas les rôles liés aux services.
Pour plus d'informations, voir [Politiques de contrôle des services (SCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) dans le *guide de AWS Organizations l'utilisateur*.
## Autorisations de rôle liées à un service pour Lake Formation
Lake Formation utilise le rôle lié au service nommé. `AWSServiceRoleForLakeFormationDataAccess` Ce rôle fournit un ensemble d'autorisations Amazon Simple Storage Service (Amazon S3) qui permettent au service intégré Lake Formation ( Amazon Athena tel que) d'accéder aux emplacements enregistrés. Lorsque vous enregistrez un emplacement de lac de données, vous devez fournir un rôle disposant des read/write autorisations Amazon S3 requises pour cet emplacement. Au lieu de créer un rôle avec les autorisations Amazon S3 requises, vous pouvez utiliser ce rôle lié à un service.
La première fois que vous nommez le rôle lié au service comme le rôle avec lequel enregistrer un chemin, le rôle lié au service et une nouvelle politique IAM sont créés en votre nom. Lake Formation ajoute le chemin à la politique en ligne et l'associe au rôle lié au service. Lorsque vous enregistrez les chemins suivants avec le rôle lié au service, Lake Formation ajoute le chemin à la politique existante.
Lorsque vous êtes connecté en tant qu'administrateur du lac de données, enregistrez l'emplacement d'un lac de données. Ensuite, dans la console IAM, recherchez le rôle `AWSServiceRoleForLakeFormationDataAccess` et consultez les politiques qui lui sont associées.
Par exemple, une fois que vous avez enregistré l'emplacement`s3://my-kinesis-test/logs`, Lake Formation crée la politique en ligne suivante et l'attache à`AWSServiceRoleForLakeFormationDataAccess`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LakeFormationDataAccessPermissionsForS3",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:s3:::my-kinesis-test/logs/*"
]
},
{
"Sid": "LakeFormationDataAccessPermissionsForS3ListBucket",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:ListBucketMultipartUploads"
],
"Resource": [
"arn:aws:s3:::my-kinesis-test"
]
}
]
}
```
------
## Création d'un rôle lié à un service pour Lake Formation
Vous n’avez pas besoin de créer manuellement un rôle lié à un service. Lorsque vous enregistrez un site Amazon S3 avec Lake Formation dans l' AWS Management Console AWS API AWS CLI, Lake Formation crée le rôle lié au service pour vous.
**Important**
Ce rôle lié à un service peut apparaître dans votre compte si vous avez effectué une action dans un autre service qui utilise les fonctions prises en charge par ce rôle. Pour en savoir plus, consultez [Un nouveau rôle est apparu dans mon compte IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_roles.html#troubleshoot_roles_new-role-appeared).
Si vous supprimez ce rôle lié à un service et que vous avez ensuite besoin de le recréer, vous pouvez utiliser la même procédure pour recréer le rôle dans votre compte. Lorsque vous enregistrez un site Amazon S3 auprès de Lake Formation, Lake Formation crée à nouveau le rôle lié au service pour vous.
Vous pouvez également utiliser la console IAM pour créer un rôle lié à un service avec le cas d'utilisation de **Lake Formation**. Dans l'API AWS CLI ou dans l' AWS API, créez un rôle lié à un service avec le nom du `lakeformation.amazonaws.com` service. Pour plus d’informations, consultez [Création d’un rôle lié à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#create-service-linked-role) dans le *Guide de l’utilisateur IAM*. Si vous supprimez ce rôle lié à un service, vous pouvez utiliser ce même processus pour créer le rôle à nouveau.
## Modification d'un rôle lié à un service pour Lake Formation
Lake Formation ne vous permet pas de modifier le rôle `AWSServiceRoleForLakeFormationDataAccess` lié au service. Après avoir créé un rôle lié à un service, vous ne pouvez pas changer le nom du rôle, car plusieurs entités peuvent faire référence à ce rôle. Néanmoins, vous pouvez modifier la description du rôle à l’aide d’IAM. Pour en savoir plus, consultez [Modification d’un rôle lié à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) dans le *Guide de l’utilisateur IAM*.
## Suppression d'un rôle lié à un service pour Lake Formation
Si vous n’avez plus besoin d’utiliser une fonctionnalité ou un service qui nécessite un rôle lié à un service, nous vous recommandons de supprimer ce rôle. De cette façon, vous n’avez aucune entité inutilisée qui n’est pas surveillée ou gérée activement. Cependant, vous devez nettoyer les ressources de votre rôle lié à un service avant de pouvoir les supprimer manuellement.
**Note**
Si le service Lake Formation utilise le rôle lorsque vous essayez de supprimer les ressources, la suppression risque d'échouer. Si cela se produit, patientez quelques minutes et réessayez.
**Pour supprimer les ressources de la Formation du Lac utilisées par la Formation du Lac**
+ Si vous avez utilisé le rôle lié à un service pour enregistrer des sites Amazon S3 auprès de Lake Formation, avant de supprimer le rôle lié au service, vous devez désenregistrer l'emplacement et le réenregistrer à l'aide d'un rôle personnalisé.
**Pour supprimer manuellement le rôle lié au service à l’aide d’IAM**
Utilisez la console IAM, le AWS CLI, ou l' AWS API pour supprimer le rôle lié au `AWSServiceRoleForLakeFormationDataAccess` service. Pour plus d’informations, veuillez consulter [Suppression d’un rôle lié à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) dans le *Guide de l’utilisateur IAM*.
Les conditions requises pour un rôle défini par l'utilisateur sont les suivantes :
+ Lors de la création du nouveau rôle, sur la page **Créer un rôle** de la console IAM, sélectionnez **AWS service**, puis sous **Choisir un cas d'utilisation**, choisissez **Lake Formation**.
Si vous créez le rôle en utilisant un chemin différent, assurez-vous que le rôle entretient une relation de confiance avec`lakeformation.amazonaws.com`. Pour plus d'informations, consultez la section [Modification d'une politique d'approbation des rôles (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-trust-policy.html).
+ Le rôle doit avoir une politique intégrée qui accorde des read/write autorisations à Amazon S3 sur le site. Voici une politique typique.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::awsexamplebucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::awsexamplebucket"
]
}
]
}
```
------
+ Ajoutez la politique de confiance suivante au rôle IAM pour permettre au service Lake Formation d'assumer le rôle et de vendre des informations d'identification temporaires aux moteurs d'analyse intégrés.
Pour inclure le contexte utilisateur d'IAM Identity Center dans les CloudTrail journaux, la politique de confiance doit autoriser l'`sts:SetContext`action.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"lakeformation.amazonaws.com"
]
},
"Action": [
"sts:AssumeRole",
"sts:SetContext"
]
}
]
}
```
------
+ L'administrateur du lac de données qui enregistre l'emplacement doit disposer de l'`iam:PassRole`autorisation associée au rôle.
Voici une politique intégrée qui accorde cette autorisation. Remplacez ** par un numéro de AWS compte valide et remplacez ** par le nom du rôle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "PassRolePermissions",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/"
]
}
]
}
```
------
+ Pour permettre à Lake Formation d'ajouter des journaux dans CloudWatch les journaux et de publier des métriques, ajoutez la politique en ligne suivante.
**Note**
L'écriture dans CloudWatch Logs entraîne des frais.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Sid1",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-lakeformation-acceleration/*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-lakeformation-acceleration/*:log-stream:*"
]
}
]
}
```
------
# Enregistrement d'un emplacement Amazon S3
Vous devez spécifier un rôle Gestion des identités et des accès AWS (IAM) lorsque vous enregistrez un emplacement Amazon Simple Storage Service (Amazon S3). Lake Formation assume ce rôle lorsqu'elle accorde des informations d'identification temporaires aux AWS services intégrés qui accèdent aux données à cet endroit.
**Important**
Évitez d'enregistrer un compartiment Amazon S3 sur lequel les paiements par les **demandeurs sont activés**. Pour les buckets enregistrés auprès de Lake Formation, le rôle utilisé pour enregistrer le bucket est toujours considéré comme le demandeur. Si un autre AWS compte accède au bucket, l'accès aux données est facturé au propriétaire du bucket si le rôle appartient au même compte que le propriétaire du bucket.
Vous pouvez utiliser la AWS Lake Formation console, l'API Lake Formation ou AWS Command Line Interface (AWS CLI) pour enregistrer un emplacement Amazon S3.
**Avant de commencer**
Passez en revue [les exigences relatives au rôle utilisé pour enregistrer l'emplacement](registration-role.md).
**Pour enregistrer un emplacement (console)**
**Important**
Les procédures suivantes supposent que le site Amazon S3 se trouve dans le même AWS compte que le catalogue de données et que les données du site ne sont pas chiffrées. Les autres sections de ce chapitre traitent de l'enregistrement entre comptes et de l'enregistrement des emplacements chiffrés.
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous en tant qu'administrateur du lac de données ou en tant qu'utilisateur disposant de l'autorisation `lakeformation:RegisterResource` IAM.
1. Dans le volet de navigation, sous **Administration**, sélectionnez **Data lake locations**.
1. Choisissez **Register location**, puis **Browse** pour sélectionner un chemin Amazon Simple Storage Service (Amazon S3).
1. (Facultatif, mais fortement recommandé) Sélectionnez **Vérifier les autorisations de localisation** pour afficher la liste de toutes les ressources existantes dans l'emplacement Amazon S3 sélectionné et leurs autorisations.
L'enregistrement de l'emplacement sélectionné peut permettre aux utilisateurs de votre Lake Formation d'accéder aux données déjà présentes à cet emplacement. La consultation de cette liste vous permet de garantir la sécurité des données existantes.
1. Pour le **rôle IAM**, choisissez le rôle `AWSServiceRoleForLakeFormationDataAccess` lié au service (par défaut) ou un rôle IAM personnalisé répondant aux exigences de. [Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md)
Vous pouvez mettre à jour un emplacement enregistré ou d'autres informations uniquement lorsque vous l'enregistrez à l'aide d'un rôle IAM personnalisé. Pour modifier un point de vente enregistré à l'aide d'un rôle lié à un service, vous devez le désenregistrer, puis l'enregistrer à nouveau.
1. Choisissez l'option **Enable Data Catalog Federation** pour autoriser Lake Formation à assumer un rôle et à vendre des informations d'identification temporaires aux AWS services intégrés afin d'accéder aux tables des bases de données fédérées. Si un emplacement est enregistré auprès de Lake Formation et que vous souhaitez utiliser le même emplacement pour une table dans une base de données fédérée, vous devez enregistrer le même emplacement à l'aide de l'option **Enable Data Catalog Federation**.
1. Choisissez le **mode d'accès hybride** pour ne pas activer les autorisations de Lake Formation par défaut. Lorsque vous enregistrez l'emplacement Amazon S3 en mode d'accès hybride, vous pouvez activer les autorisations de Lake Formation en optant pour les principes pour les bases de données et les tables situées sous cet emplacement.
Pour plus d'informations sur la configuration du mode d'accès hybride, consultez[Mode d'accès hybride](hybrid-access-mode.md).
1. Sélectionnez **Enregistrer l'emplacement**.
**Pour enregistrer un point de vente (AWS CLI)**
1.
**Enregistrez un nouvel emplacement avec Lake Formation**
Cet exemple utilise un rôle lié à un service pour enregistrer l'emplacement. Vous pouvez plutôt utiliser l'`--role-arn`argument pour indiquer votre propre rôle.
Remplacez-le ** par un chemin Amazon S3 valide, un numéro de AWS compte associé à un compte valide et ** par un rôle IAM autorisé à enregistrer un emplacement de données.
**Note**
Vous ne pouvez pas modifier les propriétés d'un point de vente enregistré s'il est enregistré à l'aide d'un rôle lié à un service.
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--use-service-linked-role
```
L'exemple suivant utilise un rôle personnalisé pour enregistrer l'emplacement.
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/
```
1.
**Pour mettre à jour une position enregistrée auprès de Lake Formation**
Vous ne pouvez modifier un emplacement enregistré que s'il est enregistré à l'aide d'un rôle IAM personnalisé. Pour un emplacement enregistré avec un rôle lié à un service, vous devez le désenregistrer et l'enregistrer à nouveau. Pour de plus amples informations, veuillez consulter [Annulation de l'enregistrement d'un site Amazon S3](unregister-location.md).
```
aws lakeformation update-resource \
--role-arn arn:aws:iam::<123456789012>:role/\
--resource-arn arn:aws:s3:::
```
```
aws lakeformation update-resource \
--resource-arn arn:aws:s3::: \
--use-service-linked-role
```
1.
**Enregistrer un emplacement de données en mode d'accès hybride avec fédération**
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--hybrid-access-enabled
```
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--with-federation
```
```
aws lakeformation update-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--hybrid-access-enabled
```
Pour plus d'informations, consultez la section Fonctionnement de l'[RegisterResource](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_RegisterResource.html)API.
**Note**
Une fois que vous avez enregistré un emplacement Amazon S3, toute AWS Glue table pointant vers cet emplacement (ou l'un de ses emplacements enfants) renvoie la valeur du `IsRegisteredWithLakeFormation` paramètre comme `true` dans l'`GetTable`appel. Il existe une limite connue selon laquelle les opérations de l'API du catalogue de données, telles que `GetTables` la mise à jour ou non de la valeur du `IsRegisteredWithLakeFormation` paramètre, renvoient la valeur par défaut, qui est fausse. `SearchTables` Il est recommandé d'utiliser l'`GetTable`API pour afficher la valeur correcte du `IsRegisteredWithLakeFormation` paramètre.
# Enregistrement d'un emplacement Amazon S3 chiffré
Lake Formation s'intègre à [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)(AWS KMS) pour vous permettre de configurer plus facilement d'autres services intégrés pour chiffrer et déchiffrer les données sur les sites Amazon Simple Storage Service (Amazon S3).
Ils Clés gérées par AWS sont tous deux gérés par AWS KMS keys le client et pris en charge. Actuellement, le côté client n' encryption/decryption est pris en charge qu'avec Athena.
Vous devez spécifier un rôle Gestion des identités et des accès AWS (IAM) lorsque vous enregistrez un emplacement Amazon S3. Pour les sites Amazon S3 chiffrés, le rôle doit être autorisé à chiffrer et à déchiffrer les données avec le AWS KMS key, ou la politique de clé KMS doit accorder des autorisations sur la clé du rôle.
**Important**
Évitez d'enregistrer un compartiment Amazon S3 sur lequel les paiements par les **demandeurs sont activés**. Pour les buckets enregistrés auprès de Lake Formation, le rôle utilisé pour enregistrer le bucket est toujours considéré comme le demandeur. Si un autre AWS compte accède au bucket, l'accès aux données est facturé au propriétaire du bucket si le rôle appartient au même compte que le propriétaire du bucket.
Lake Formation utilise un rôle lié à un service pour enregistrer l'emplacement de vos données. Ce rôle présente toutefois plusieurs [limites](service-linked-role-limitations.md). En raison de ces contraintes, nous recommandons plutôt de créer et d'utiliser un rôle IAM personnalisé pour plus de flexibilité et de contrôle. Le rôle personnalisé que vous créez pour enregistrer l'emplacement doit répondre aux exigences spécifiées dans[Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md).
**Important**
Si vous avez utilisé un Clé gérée par AWS pour chiffrer l'emplacement Amazon S3, vous ne pouvez pas utiliser le rôle lié au service Lake Formation. Vous devez utiliser un rôle personnalisé et ajouter des autorisations IAM sur la clé du rôle. Les détails sont fournis plus loin dans cette section.
Les procédures suivantes expliquent comment enregistrer un emplacement Amazon S3 chiffré à l'aide d'une clé gérée par le client ou d'un Clé gérée par AWS.
+ [Enregistrement d'un emplacement chiffré à l'aide d'une clé gérée par le client](#proc-register-cust-cmk)
+ [Enregistrer une position cryptée avec un Clé gérée par AWS](#proc-register-aws-cmk)
**Avant de commencer**
Passez en revue [les exigences relatives au rôle utilisé pour enregistrer l'emplacement](registration-role.md).
**Pour enregistrer un emplacement Amazon S3 chiffré à l'aide d'une clé gérée par le client**
**Note**
Si la clé KMS ou l'emplacement Amazon S3 ne se trouvent pas dans le même AWS compte que le catalogue de données, suivez [Enregistrement d'un emplacement Amazon S3 chiffré sur plusieurs AWS comptes](register-cross-encrypted.md) plutôt les instructions indiquées.
1. Ouvrez la AWS KMS console à l'[https://console---aws.amazon.com.rproxy.govskope.usadresse /kms](https://console.aws.amazon.com/kms) et connectez-vous en tant qu'utilisateur administratif Gestion des identités et des accès AWS (IAM) ou en tant qu'utilisateur pouvant modifier la politique de clé KMS utilisée pour chiffrer l'emplacement.
1. Dans le volet de navigation, sélectionnez **Clés gérées par le client**, puis choisissez le nom de la clé KMS souhaitée.
1. Sur la page de détails des clés KMS, choisissez l'onglet **Politique clé**, puis effectuez l'une des opérations suivantes pour ajouter votre rôle personnalisé ou le rôle lié au service Lake Formation en tant qu'utilisateur clé KMS :
+ **Si la vue par défaut s'affiche** (avec les sections **Administrateurs clés****, Suppression** des **clés, Utilisateurs clés** et **Autres AWS comptes**), dans la section **Utilisateurs clés**, ajoutez votre rôle personnalisé ou le rôle lié au service Lake Formation. `AWSServiceRoleForLakeFormationDataAccess`
+ **Si la politique clé (JSON) s'affiche**, modifiez la politique pour ajouter votre rôle personnalisé ou le rôle lié au service Lake Formation `AWSServiceRoleForLakeFormationDataAccess` à l'objet « Autoriser l'utilisation de la clé », comme indiqué dans l'exemple suivant.
**Note**
Si cet objet est manquant, ajoutez-le avec les autorisations indiquées dans l'exemple. L'exemple utilise le rôle lié à un service.
```
...
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/aws-service-role/lakeformation.amazonaws.com/AWSServiceRoleForLakeFormationDataAccess",
"arn:aws:iam::111122223333:user/keyuser"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
...
```
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous en tant qu'administrateur du lac de données ou en tant qu'utilisateur disposant de l'autorisation `lakeformation:RegisterResource` IAM.
1. Dans le volet de navigation, sous **Administration**, sélectionnez **Data lake locations**.
1. Choisissez **Register location**, puis **Browse** pour sélectionner un chemin Amazon Simple Storage Service (Amazon S3).
1. (Facultatif, mais fortement recommandé) Choisissez **Vérifier les autorisations de localisation** pour afficher la liste de toutes les ressources existantes dans l'emplacement Amazon S3 sélectionné ainsi que leurs autorisations.
L'enregistrement de l'emplacement sélectionné peut permettre aux utilisateurs de votre Lake Formation d'accéder aux données déjà présentes à cet emplacement. La consultation de cette liste vous permet de garantir la sécurité des données existantes.
1. Pour le **rôle IAM**, choisissez soit le rôle `AWSServiceRoleForLakeFormationDataAccess` lié au service (par défaut), soit votre rôle personnalisé qui répond aux. [Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md)
1. Choisissez **Enregistrer l'emplacement**.
Pour de plus amples informations sur le rôle lié à un service, veuillez consulter [Autorisations de rôle liées à un service pour Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Pour enregistrer une position Amazon S3 chiffrée à l'aide d'un Clé gérée par AWS**
**Important**
Si l'emplacement Amazon S3 n'est pas enregistré dans le même AWS compte que le catalogue de données, suivez [Enregistrement d'un emplacement Amazon S3 chiffré sur plusieurs AWS comptes](register-cross-encrypted.md) plutôt les instructions indiquées dans la section.
1. Créez un rôle IAM à utiliser pour enregistrer l'emplacement. Assurez-vous qu'il répond aux exigences répertoriées dans[Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md).
1. Ajoutez la politique intégrée suivante au rôle. Il accorde des autorisations sur la clé du rôle. La `Resource` spécification doit indiquer le nom de ressource Amazon (ARN) du Clé gérée par AWS. Vous pouvez obtenir l'ARN depuis la AWS KMS console. Pour obtenir le bon ARN, assurez-vous de vous connecter à la AWS KMS console avec le même AWS compte et la même région Clé gérée par AWS que ceux utilisés pour chiffrer l'emplacement.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
]
}
```
------
Vous pouvez utiliser des alias de clé KMS au lieu de l'ID de clé - `arn:aws:kms:region:account-id:key/alias/your-key-alias`
Pour plus d'informations, consultez la AWS KMS section [Alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html) du Guide du AWS Key Management Service développeur.
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous en tant qu'administrateur du lac de données ou en tant qu'utilisateur disposant de l'autorisation `lakeformation:RegisterResource` IAM.
1. Dans le volet de navigation, sous **Administration**, sélectionnez **Data lake locations**.
1. Choisissez **Register location**, puis **Browse** pour sélectionner un chemin Amazon S3.
1. (Facultatif, mais fortement recommandé) Choisissez **Vérifier les autorisations de localisation** pour afficher la liste de toutes les ressources existantes dans l'emplacement Amazon S3 sélectionné ainsi que leurs autorisations.
L'enregistrement de l'emplacement sélectionné peut permettre aux utilisateurs de votre Lake Formation d'accéder aux données déjà présentes à cet emplacement. La consultation de cette liste vous permet de garantir la sécurité des données existantes.
1. Pour le **rôle IAM**, choisissez le rôle que vous avez créé à l'étape 1.
1. Choisissez **Enregistrer l'emplacement**.
# Enregistrement d'un emplacement Amazon S3 sur un autre AWS compte
AWS Lake Formation vous permet d'enregistrer des sites AWS Amazon Simple Storage Service (Amazon S3) sur plusieurs comptes. Par exemple, s'il AWS Glue Data Catalog se trouve dans le compte A, un utilisateur du compte A peut enregistrer un compartiment Amazon S3 dans le compte B.
L'enregistrement d'un compartiment Amazon S3 dans le AWS compte B à l'aide d'un rôle Gestion des identités et des accès AWS (IAM) dans le AWS compte A nécessite les autorisations suivantes :
+ Le rôle du compte A doit accorder des autorisations sur le compartiment du compte B.
+ La politique de compartiment du compte B doit accorder des autorisations d'accès au rôle dans le compte A.
**Important**
Évitez d'enregistrer un compartiment Amazon S3 sur lequel les paiements par les **demandeurs sont activés**. Pour les buckets enregistrés auprès de Lake Formation, le rôle utilisé pour enregistrer le bucket est toujours considéré comme le demandeur. Si un autre AWS compte accède au bucket, l'accès aux données est facturé au propriétaire du bucket si le rôle appartient au même compte que le propriétaire du bucket.
Vous ne pouvez pas utiliser le rôle lié au service Lake Formation pour enregistrer une position sur un autre compte. Vous devez plutôt utiliser un rôle défini par l'utilisateur. Le rôle doit répondre aux exigences de[Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md). Pour de plus amples informations sur le rôle lié à un service, veuillez consulter [Autorisations de rôle liées à un service pour Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Avant de commencer**
Passez en revue [les exigences relatives au rôle utilisé pour enregistrer l'emplacement](registration-role.md).
**Pour enregistrer une position dans un autre AWS compte**
**Note**
Si l'emplacement est crypté, suivez [Enregistrement d'un emplacement Amazon S3 chiffré sur plusieurs AWS comptes](register-cross-encrypted.md) plutôt les instructions indiquées.
La procédure suivante suppose qu'un mandant du compte 1111-2222-3333, qui contient le catalogue de données, souhaite enregistrer le compartiment Amazon S3, qui se trouve dans le compte `awsexamplebucket1` 1234-5678-9012.
1. Dans le compte 1111-2222-3333, connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Créez un nouveau rôle ou consultez un rôle existant qui répond aux exigences de[Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md). Assurez-vous que le rôle accorde des autorisations à Amazon S3 sur`awsexamplebucket1`.
1. Ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). Connectez-vous avec le compte 1234-5678-9012.
1. Dans la liste **Nom du compartiment**, choisissez le nom du compartiment,`awsexamplebucket1`.
1. Choisissez **Autorisations**.
1. Sur la page **Autorisations**, choisissez **Bucket Policy**.
1. Dans l'**éditeur de politique Bucket**, collez la politique suivante. Remplacez ** par le nom de votre rôle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action":"s3:ListBucket",
"Resource":"arn:aws:s3:::awsexamplebucket1"
},
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:PutObject"
],
"Resource":"arn:aws:s3:::awsexamplebucket1/*"
}
]
}
```
------
1. Choisissez **Enregistrer**.
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous au compte 1111-2222-3333 en tant qu'administrateur du lac de données ou en tant qu'utilisateur disposant des autorisations suffisantes pour enregistrer des emplacements.
1. Dans le volet de navigation, sous **Administration**, sélectionnez **Data lake locations**.
1. Sur la page des **emplacements des Data Lake**, choisissez **Enregistrer l'emplacement**.
1. Sur la **page Enregistrer l'emplacement**, pour le **chemin Amazon S3**, entrez le nom du compartiment`s3://awsexamplebucket1`.
**Note**
**Vous devez saisir le nom du bucket car les buckets multi-comptes n'apparaissent pas dans la liste lorsque vous choisissez Browse.**
1. Pour le **rôle IAM**, choisissez votre rôle.
1. Choisissez **Enregistrer l'emplacement**.
# Enregistrement d'un emplacement Amazon S3 chiffré sur plusieurs AWS comptes
AWS Lake Formation s'intègre à [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)(AWS KMS) pour vous permettre de configurer plus facilement d'autres services intégrés pour chiffrer et déchiffrer les données sur les sites Amazon Simple Storage Service (Amazon S3).
Les deux clés sont gérées par le client et Clés gérées par AWS sont prises en charge. Le côté client n' encryption/decryption est pas pris en charge.
**Important**
Évitez d'enregistrer un compartiment Amazon S3 sur lequel les paiements par les **demandeurs sont activés**. Pour les buckets enregistrés auprès de Lake Formation, le rôle utilisé pour enregistrer le bucket est toujours considéré comme le demandeur. Si un autre AWS compte accède au bucket, l'accès aux données est facturé au propriétaire du bucket si le rôle appartient au même compte que le propriétaire du bucket.
Cette section explique comment enregistrer un emplacement Amazon S3 dans les circonstances suivantes :
+ Les données de l'emplacement Amazon S3 sont chiffrées à l'aide d'une clé KMS créée dans AWS KMS.
+ L'emplacement Amazon S3 n'est pas enregistré dans le même AWS compte que le AWS Glue Data Catalog.
+ La clé KMS se trouve ou non dans le même AWS compte que le catalogue de données.
L'enregistrement d' AWS KMS un compartiment Amazon S3 chiffré dans le AWS compte B à l'aide d'un rôle Gestion des identités et des accès AWS (IAM) dans le AWS compte A nécessite les autorisations suivantes :
+ Le rôle du compte A doit accorder des autorisations sur le compartiment du compte B.
+ La politique de compartiment du compte B doit accorder des autorisations d'accès au rôle dans le compte A.
+ Si la clé KMS se trouve dans le compte B, la politique clé doit accorder l'accès au rôle dans le compte A, et le rôle dans le compte A doit accorder des autorisations sur la clé KMS.
Dans la procédure suivante, vous allez créer un rôle dans le AWS compte qui contient le catalogue de données (compte A dans la discussion précédente). Vous utilisez ensuite ce rôle pour enregistrer l'emplacement. Lake Formation assume ce rôle lors de l'accès aux données sous-jacentes dans Amazon S3. Le rôle assumé dispose des autorisations requises sur la clé KMS. Par conséquent, vous n'avez pas à accorder d'autorisations sur la clé KMS aux principaux accédant aux données sous-jacentes via des tâches ETL ou des services intégrés tels que Amazon Athena.
**Important**
Vous ne pouvez pas utiliser le rôle lié au service Lake Formation pour enregistrer une position sur un autre compte. Vous devez plutôt utiliser un rôle défini par l'utilisateur. Le rôle doit répondre aux exigences de[Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md). Pour de plus amples informations sur le rôle lié à un service, veuillez consulter [Autorisations de rôle liées à un service pour Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Avant de commencer**
Passez en revue [les exigences relatives au rôle utilisé pour enregistrer l'emplacement](registration-role.md).
**Pour enregistrer une position Amazon S3 chiffrée sur plusieurs AWS comptes**
1. Dans le même AWS compte que le catalogue de données, connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) l'adresse.
1. Créez un nouveau rôle ou consultez un rôle existant qui répond aux exigences de[Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md). Assurez-vous que le rôle inclut une politique qui accorde des autorisations à Amazon S3 sur le site.
1. Si la clé KMS ne se trouve pas dans le même compte que le catalogue de données, ajoutez au rôle une politique intégrée qui accorde les autorisations requises sur la clé KMS. Voici un exemple de politique . Remplacez la région et l'ID de compte par la région et le numéro de compte de la clé KMS. Remplacez ** par l'identifiant de la clé.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/"
}
]
}
```
------
1. Sur la console Amazon S3, ajoutez une politique de compartiment accordant les autorisations Amazon S3 requises au rôle. Voici un exemple de stratégie de compartiment. Remplacez l'ID de AWS compte par le numéro de compte du catalogue de données, ** par le nom de votre rôle et ** par le nom du bucket.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action":"s3:ListBucket",
"Resource":"arn:aws:s3:::"
},
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:PutObject"
],
"Resource":"arn:aws:s3:::/*"
}
]
}
```
------
1. Dans AWS KMS, ajoutez le rôle en tant qu'utilisateur de la clé KMS.
1. Ouvrez la AWS KMS console à l'adresse [https://console.aws.amazon.com/kms.](https://console.aws.amazon.com/kms) Connectez-vous ensuite en tant qu'administrateur ou en tant qu'utilisateur pouvant modifier la politique de clé de la clé KMS utilisée pour chiffrer l'emplacement.
1. Dans le volet de navigation, choisissez **Customer managed keys**, puis choisissez le nom de la clé KMS.
1. Sur la page des détails de la clé KMS, sous l'onglet Stratégie **clé**, si la vue JSON de la politique clé ne s'affiche pas, choisissez **Basculer vers la vue politique**.
1. Dans la section **Politique clé**, choisissez **Modifier** et ajoutez le nom de ressource Amazon (ARN) du rôle à l'`Allow use of the key`objet, comme indiqué dans l'exemple suivant.
**Note**
Si cet objet est manquant, ajoutez-le avec les autorisations indiquées dans l'exemple.
```
...
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam:::role/"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
...
```
Pour plus d'informations, voir [Autoriser les utilisateurs d'autres comptes à utiliser une clé KMS](https://docs.amazonaws.cn/en_us/kms/latest/developerguide/key-policy-modifying-external-accounts.html) dans le *Guide du AWS Key Management Service développeur*.
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous au AWS compte Data Catalog en tant qu'administrateur du lac de données.
1. Dans le volet de navigation, sous **Administration**, sélectionnez **Data lake locations**.
1. Choisissez **Enregistrer l'emplacement**.
1. Sur la **page Enregistrer l'emplacement**, pour le **chemin Amazon S3**, entrez le chemin de localisation sous la forme**s3://**/****. **Remplacez-le par le nom du compartiment et ** par le reste du chemin correspondant à l'emplacement.
**Note**
**Vous devez saisir le chemin car les compartiments multicomptes n'apparaissent pas dans la liste lorsque vous choisissez Parcourir.**
1. Pour le **rôle IAM**, choisissez le rôle à l'étape 2.
1. Choisissez **Enregistrer l'emplacement**.
# Annulation de l'enregistrement d'un site Amazon S3
Vous pouvez annuler l'enregistrement d'un site Amazon Simple Storage Service (Amazon S3) si vous ne souhaitez plus qu'il soit géré par Lake Formation. L'annulation de l'enregistrement d'un emplacement n'affecte pas les autorisations de localisation des données de Lake Formation accordées pour cet emplacement. Vous pouvez réenregistrer un emplacement que vous avez désenregistré, et les autorisations de localisation des données restent en vigueur. Vous pouvez utiliser un autre rôle pour réenregistrer l'emplacement.
**Pour désenregistrer une position (console)**
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous en tant qu'administrateur du lac de données ou en tant qu'utilisateur disposant de l'autorisation `lakeformation:RegisterResource` IAM.
1. Dans le volet de navigation, sous **Administration**, sélectionnez **Data lake locations**.
1. Sélectionnez un emplacement, puis dans le menu **Actions**, choisissez **Supprimer**.
1. Lorsque vous êtes invité à confirmer, choisissez **Supprimer**.
# Mode d'accès hybride
AWS Lake Formation le *mode d'accès hybride* prend en charge deux voies d'autorisation vers les mêmes AWS Glue Data Catalog objets.
Dans le premier parcours, Lake Formation vous permet de sélectionner des principes spécifiques et de leur accorder les autorisations Lake Formation pour accéder aux catalogues, aux bases de données, aux tables et aux vues en vous inscrivant. La deuxième voie permet à tous les autres principaux d'accéder à ces ressources via les politiques principales IAM par défaut pour Amazon S3 et AWS Glue les actions.
Lorsque vous enregistrez un site Amazon S3 auprès de Lake Formation, vous avez la possibilité d'appliquer les autorisations de Lake Formation à toutes les ressources de cet emplacement ou d'utiliser le mode d'accès hybride. Le mode d'accès hybride applique uniquement `CREATE_TABLE` `CREATE_PARTITION` les `UPDATE_TABLE` autorisations par défaut. Lorsqu'un site Amazon S3 est en mode hybride, vous pouvez activer les autorisations de Lake Formation en choisissant des principes pour les objets du catalogue de données situés sous cet emplacement. Cela signifie que les autorisations Lake Formation et les autorisations IAM peuvent contrôler l'accès à ces données. Cela signifie que les principaux participants auront besoin à la fois des autorisations Lake Formation et des autorisations IAM pour accéder aux données, tandis que non-opted-in les principaux continueront d'accéder aux données en utilisant uniquement les autorisations IAM.
Ainsi, le mode d'accès hybride offre la flexibilité nécessaire pour activer de manière sélective Lake Formation pour les catalogues, les bases de données et les tables de votre catalogue de données pour un ensemble spécifique d'utilisateurs sans interrompre l'accès pour les autres utilisateurs ou charges de travail existants.
![\[Compte AWS architecture showing data flow between S3, Glue, Lake Formation, Athena, and IAM roles.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/hybrid-access-mode-concept.png)
Pour les considérations et les restrictions, consultez [Considérations et limites relatives au mode d'accès hybride](notes-hybrid.md).Termes et définitions
Voici les définitions des ressources du catalogue de données en fonction de la façon dont vous configurez les autorisations d'accès :
Ressource Lake Formation
Une ressource enregistrée auprès de Lake Formation. Les utilisateurs ont besoin des autorisations de Lake Formation pour accéder à la ressource.
AWS Glue ressource
Une ressource qui n'est pas enregistrée auprès de Lake Formation. Les utilisateurs n'ont besoin que d'autorisations IAM pour accéder à la ressource, car celle-ci dispose d'autorisations de `IAMAllowedPrincipals` groupe. Les autorisations de Lake Formation ne sont pas appliquées.
Pour plus d'informations sur les autorisations de `IAMAllowedPrincipals` groupe, consultez[Autorisations relatives aux métadonnées](metadata-permissions.md).
Ressource hybride
Une ressource enregistrée en mode d'accès hybride. En fonction des utilisateurs accédant à la ressource, celle-ci passe de manière dynamique à une ressource de Lake Formation ou à une AWS Glue ressource.
## Cas d'utilisation courants du mode d'accès hybride
Vous pouvez utiliser le mode d'accès hybride pour fournir un accès dans le cadre de scénarios de partage de données à compte unique ou entre comptes :
**Scénarios de compte unique**
+ **Convertir une AWS Glue ressource en ressource hybride** : dans ce scénario, vous n'utilisez pas actuellement Lake Formation mais souhaitez adopter les autorisations Lake Formation pour les objets du catalogue de données. Lorsque vous enregistrez l'emplacement Amazon S3 en mode d'accès hybride, vous pouvez accorder des autorisations Lake Formation aux utilisateurs qui optent pour des bases de données et des tables spécifiques pointant vers cet emplacement.
+ **Conversion d'une ressource Lake Formation en ressource hybride** — Actuellement, vous utilisez les autorisations Lake Formation pour contrôler l'accès à une base de données de catalogue de données, mais vous souhaitez fournir l'accès à de nouveaux principaux en utilisant les autorisations IAM pour Amazon S3 et AWS Glue sans interrompre les autorisations Lake Formation existantes.
Lorsque vous mettez à jour l'enregistrement d'un emplacement de données en mode d'accès hybride, les nouveaux principaux peuvent accéder à la base de données du catalogue de données pointant vers l'emplacement Amazon S3 en utilisant les politiques d'autorisation IAM sans interrompre les autorisations Lake Formation des utilisateurs existants.
Avant de mettre à jour l'enregistrement de la localisation des données pour activer le mode d'accès hybride, vous devez d'abord activer les principaux qui accèdent actuellement à la ressource avec les autorisations de Lake Formation.
Cela permet d'éviter toute interruption potentielle du flux de travail en cours.
Vous devez également `Super` autoriser le `IAMAllowedPrincipal` groupe à accéder aux tables de la base de données.
**Scénarios de partage de données entre comptes**
+ **Partagez AWS Glue des ressources à l'aide du mode d'accès hybride** : dans ce scénario, le compte producteur possède des tables dans une base de données qui sont actuellement partagées avec un compte client conformément aux politiques d'autorisation IAM pour Amazon S3 et aux AWS Glue actions. L'emplacement des données de la base de données n'est pas enregistré auprès de Lake Formation.
Avant d'enregistrer l'emplacement des données en mode d'accès hybride, vous devez mettre à jour les **paramètres de version du compte Cross** vers la version 4. La version 4 fournit les nouvelles politiques AWS RAM d'autorisation requises pour le partage entre comptes lorsque le `IAMAllowedPrincipal` groupe dispose d'une `Super` autorisation sur la ressource. Pour les ressources disposant d'autorisations de `IAMAllowedPrincipal` groupe, vous pouvez accorder des autorisations de Lake Formation à des comptes externes et les autoriser à utiliser les autorisations de Lake Formation. L'administrateur du lac de données du compte destinataire peut accorder des autorisations Lake Formation aux principaux du compte et les autoriser à appliquer les autorisations Lake Formation.
+ **Partagez les ressources de Lake Formation en mode d'accès hybride** — Actuellement, le compte producteur contient des tables dans une base de données qui sont partagées avec un compte consommateur appliquant les autorisations de Lake Formation. L'emplacement des données de la base de données est enregistré auprès de Lake Formation.
Dans ce cas, vous pouvez mettre à jour l'enregistrement de l'emplacement Amazon S3 en mode d'accès hybride et partager les données d'Amazon S3 et les métadonnées de Data Catalog en utilisant les politiques de compartiment Amazon S3 et les politiques de ressources du catalogue de données avec les principaux du compte client. Vous devez réoctroyer les autorisations Lake Formation existantes et accepter les principales avant de mettre à jour l'enregistrement de la position Amazon S3. Vous devez également `Super` autoriser le `IAMAllowedPrincipals` groupe à accéder aux tables de la base de données.
**Topics**
+ [Cas d'utilisation courants du mode d'accès hybride](#hybrid-access-mode-use-cases)
+ [Comment fonctionne le mode d'accès hybride](hybrid-access-workflow.md)
+ [Configuration du mode d'accès hybride : scénarios courants](hybrid-access-setup.md)
+ [Supprimer les principes et les ressources du mode d'accès hybride](delete-hybrid-access.md)
+ [Affichage des principes et des ressources en mode d'accès hybride](view-hybrid-access.md)
+ [Ressources supplémentaires](additional-resources-hybrid.md)
# Comment fonctionne le mode d'accès hybride
Le schéma suivant montre comment fonctionne l'autorisation de Lake Formation en mode d'accès hybride lorsque vous interrogez les ressources du catalogue de données.
![\[AWS Lake Formation authorization process flowchart for hybrid access mode queries.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/hybrid-workflow.png)
Avant d'accéder aux données de votre lac de données, un administrateur de lac de données ou un utilisateur disposant d'autorisations administratives définit des politiques utilisateur individuelles pour les tables du catalogue de données afin d'autoriser ou de refuser l'accès aux tables de votre catalogue de données. Ensuite, un directeur autorisé à effectuer une `RegisterResource` opération enregistre l'emplacement de la table sur Amazon S3 auprès de Lake Formation en mode d'accès hybride. Si aucun emplacement de données n'est enregistré auprès de Lake Formation, l'administrateur accorde des autorisations Lake Formation à des utilisateurs spécifiques sur les bases de données et les tables du catalogue de données et les autorise à utiliser les autorisations de Lake Formation pour ces bases de données et tables en mode d'accès hybride.
1. **Soumet une requête** : un directeur soumet une requête ou un script ETL à l'aide d'un service intégré tel qu'Amazon Athena, AWS Glue Amazon EMR ou Amazon Redshift Spectrum.
1. **Demande des données** : le moteur d'analyse intégré identifie la table demandée et envoie la demande de métadonnées au catalogue de données (`GetTable`,`GetDatabase`).
1. **Vérifie les autorisations** - Le catalogue de données vérifie les autorisations d'accès du principal demandeur auprès de Lake Formation.
1. Si aucune autorisation de `IAMAllowedPrincipals` groupe n'est attachée à la table, les autorisations de Lake Formation sont appliquées.
1. Si le principal a choisi d'utiliser les autorisations de Lake Formation en mode d'accès hybride et que des autorisations de `IAMAllowedPrincipals` groupe sont associées à la table, les autorisations de Lake Formation sont appliquées. Le moteur de requête applique les filtres qu'il a reçus de Lake Formation et renvoie les données à l'utilisateur.
1. Si l'emplacement de la table n'est pas enregistré auprès de Lake Formation et que le directeur n'a pas choisi d'utiliser les autorisations de Lake Formation en mode d'accès hybride, le catalogue de données vérifie si des autorisations de `IAMAllowedPrincipals` groupe sont associées à la table. Si cette autorisation existe sur la table, tous les principaux du compte obtiennent `Super` ou obtiennent `All` des autorisations sur la table.
La vente d'identifiants Lake Formation n'est pas disponible, même en cas d'inscription, sauf si l'emplacement des données est enregistré auprès de Lake Formation.
1. **Obtenir des informations d'identification** — Le catalogue de données vérifie et indique au moteur si l'emplacement de la table est enregistré auprès de Lake Formation ou non. Si les données sous-jacentes sont enregistrées auprès de Lake Formation, le moteur d'analyse demande à Lake Formation des informations d'identification temporaires pour accéder aux données du compartiment Amazon S3.
1. **Obtenir des données** — Si le principal est autorisé à accéder aux données de la table, Lake Formation fournit un accès temporaire au moteur d'analyse intégré. À l'aide de l'accès temporaire, le moteur d'analyse extrait les données d'Amazon S3 et effectue le filtrage nécessaire, tel que le filtrage par colonne, ligne ou cellule. Lorsque le moteur a terminé d'exécuter la tâche, il renvoie les résultats à l'utilisateur. Ce processus est appelé distributeur d'informations d'identification. Pour plus d'informations, voir[Intégration de services tiers avec Lake Formation](Integrating-with-LakeFormation.md).
1.
Si l'emplacement des données de la table n'est pas enregistré auprès de Lake Formation, le deuxième appel du moteur d'analyse est directement envoyé à Amazon S3. La politique de compartiment Amazon S3 et la politique utilisateur IAM concernées sont évaluées pour l'accès aux données. Chaque fois que vous utilisez des politiques IAM, veillez à respecter les bonnes pratiques IAM. Pour plus d'informations, consultez [la section Bonnes pratiques en matière de sécurité dans IAM dans le guide de l'utilisateur d'IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html).
# Configuration du mode d'accès hybride : scénarios courants
Comme pour les autorisations de Lake Formation, vous disposez généralement de deux types de scénarios dans lesquels vous pouvez utiliser le mode d'accès hybride pour gérer l'accès aux données : fournir un accès aux principaux au sein d'un seul Compte AWS et fournir un accès à un externe Compte AWS ou à un principal.
Cette section fournit des instructions pour configurer le mode d'accès hybride dans les scénarios suivants :
**Gérez les autorisations en mode d'accès hybride en une seule fois Compte AWS**
+ [Conversion d'une AWS Glue ressource en ressource hybride](hybrid-access-mode-new.md)— Vous fournissez actuellement l'accès aux tables d'une base de données à tous les principaux de votre compte à l'aide des autorisations IAM pour Amazon S3, AWS Glue mais vous souhaitez adopter Lake Formation pour gérer les autorisations de manière progressive.
+ [Conversion d'une ressource de la Lake Formation en une ressource hybride](hybrid-access-mode-update.md)— Vous utilisez actuellement Lake Formation pour gérer l'accès aux tables d'une base de données pour tous les principaux de votre compte, mais vous souhaitez utiliser Lake Formation uniquement pour des principes spécifiques. Vous souhaitez donner accès à de nouveaux principaux en utilisant les autorisations IAM pour AWS Glue Amazon S3 sur la même base de données et les mêmes tables.
**Gérez les autorisations en mode d'accès hybride sur Compte AWS s**
+ [Partage d'une AWS Glue ressource à l'aide du mode d'accès hybride](hybrid-access-mode-cross-account.md)— Vous n'utilisez actuellement pas Lake Formation pour gérer les autorisations associées à une table, mais vous souhaitez appliquer les autorisations Lake Formation pour permettre aux principaux d'accéder à un autre compte.
+ [Partage d'une ressource de Lake Formation à l'aide du mode d'accès hybride](hybrid-access-mode-cross-account-IAM.md)— Vous utilisez Lake Formation pour gérer l'accès à une table, mais vous souhaitez fournir l'accès aux principaux d'un autre compte en utilisant les autorisations IAM pour AWS Glue Amazon S3 sur la même base de données et les mêmes tables.
**Configuration du mode d'accès hybride — Étapes de haut niveau**
1. Enregistrez l'emplacement des données Amazon S3 auprès de Lake Formation en sélectionnant le **mode d'accès hybride**.
1. Les principaux doivent être `DATA_LOCATION` autorisés à accéder à l'emplacement d'un lac de données pour créer des tables ou des bases de données du catalogue de données pointant vers cet emplacement.
1. Définissez le **paramètre de version multi-comptes** sur Version 4.
1. Accordez des autorisations détaillées à des utilisateurs ou à des rôles IAM spécifiques sur les bases de données et les tables. Dans le même temps, assurez-vous de définir `Super` des `All` autorisations pour le `IAMAllowedPrincipals` groupe sur la base de données et sur toutes les tables ou sur certaines d'entre elles.
1. Choisissez les principes et les ressources. Les autres principaux du compte peuvent continuer à accéder aux bases de données et aux tables en utilisant les politiques d'autorisation IAM pour AWS Glue les actions Amazon S3.
1. Nettoyez éventuellement les politiques d'autorisation IAM pour Amazon S3 pour les principaux utilisateurs qui ont choisi d'utiliser les autorisations de Lake Formation.
# Conditions préalables à la configuration du mode d'accès hybride
Les conditions requises pour configurer le mode d'accès hybride sont les suivantes :
**Note**
Nous recommandons à un administrateur de Lake Formation d'enregistrer l'emplacement Amazon S3 en mode d'accès hybride et d'opter pour les principes et les ressources.
1. Accordez l'autorisation de localisation des données (`DATA_LOCATION_ACCESS`) pour créer des ressources de catalogue de données pointant vers les sites Amazon S3. Les autorisations de localisation des données contrôlent la possibilité de créer des catalogues de données, des bases de données et des tables pointant vers des emplacements Amazon S3 particuliers.
1. Pour partager les ressources du catalogue de données avec un autre compte en mode d'accès hybride (sans supprimer les autorisations de `IAMAllowedPrincipals` groupe associées à la ressource), vous devez mettre à jour les **paramètres de version multi-comptes** vers la version 4 ou supérieure. Pour mettre à jour la version à l'aide de la console Lake Formation, choisissez **la version 4** ou **la version 5** dans **les paramètres de version entre comptes** sur la page des **paramètres du catalogue de données**.
Vous pouvez également utiliser la `put-data-lake-settings` AWS CLI commande pour définir le `CROSS_ACCOUNT_VERSION` paramètre sur la version 4 ou 5 :
```
aws lakeformation put-data-lake-settings --region us-east-1 --data-lake-settings file://settings
{
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam::<111122223333>:user/"
}
],
"CreateDatabaseDefaultPermissions": [],
"CreateTableDefaultPermissions": [],
"Parameters": {
"CROSS_ACCOUNT_VERSION": "5"
}
}
```
1.
Pour accorder des autorisations entre comptes en mode d'accès hybride, le concédant doit disposer des autorisations IAM requises pour AWS Glue les services et les services. AWS RAM La politique AWS gérée `AWSLakeFormationCrossAccountManager` accorde les autorisations requises.
Pour permettre le partage de données entre comptes en mode d'accès hybride, nous avons mis à jour la politique `AWSLakeFormationCrossAccountManager` gérée en ajoutant deux nouvelles autorisations IAM :
+ RAM : ListResourceSharePermissions
+ RAM : AssociateResourceSharePermission
**Note**
Si vous n'utilisez pas la politique AWS gérée pour le rôle de donateur, ajoutez les politiques ci-dessus à vos politiques personnalisées.
## Emplacement du compartiment Amazon S3 et accès utilisateur
Lorsque vous créez un catalogue, une base de données ou une table dans le AWS Glue Data Catalog, vous pouvez spécifier l'emplacement du compartiment Amazon S3 des données sous-jacentes et les enregistrer auprès de Lake Formation. Les tableaux ci-dessous décrivent le fonctionnement des autorisations pour AWS Glue les utilisateurs (principaux) de Lake Formation en fonction de l'emplacement des données Amazon S3 de la table ou de la base de données.
**Emplacement Amazon S3 enregistré auprès de Lake Formation**
| Emplacement d'une base de données sur Amazon S3 | AWS Glue utilisateurs | Utilisateurs de Lake Formation |
| --- | --- | --- |
| Enregistré auprès de Lake Formation (en mode d'accès hybride ou en mode Lake Formation) | read/write Accédez à l'emplacement des données Amazon S3 en héritant des autorisations du groupe IAMAllowed Principals (super accès). | Héritez des autorisations permettant de créer des tables à partir de l'autorisation CREATE TABLE qui leur a été accordée. |
| Aucun emplacement Amazon S3 associé | L'autorisation DATA LOCATION explicite est requise pour exécuter les instructions CREATE TABLE et INSERT TABLE. | L'autorisation DATA LOCATION explicite est requise pour exécuter les instructions CREATE TABLE et INSERT TABLE. |
****IsRegisteredWithLakeFormation**propriété de la table**
La `IsRegisteredWithLakeFormation` propriété d'une table indique si l'emplacement des données de la table est enregistré auprès de Lake Formation pour le demandeur. Si le mode d'autorisation de l'emplacement est enregistré sous le nom de Lake Formation, la `IsRegisteredWithLakeFormation` propriété est `true` réservée à tous les utilisateurs accédant à l'emplacement des données, car tous les utilisateurs sont considérés comme ayant opté pour cette table. Si l'emplacement est enregistré en mode d'accès hybride, la valeur est définie sur `true` uniquement pour les utilisateurs qui ont opté pour cette table.
**Fonctionnement d’`IsRegisteredWithLakeFormation`**
| Mode d'autorisation | Utilisateurs/Rôles | `IsRegisteredWithLakeFormation` | Description |
| --- | --- | --- | --- |
| Lake Formation | Tous | True | Lorsqu'un emplacement est enregistré auprès de Lake Formation, la `IsRegisteredWithLakeFormation` propriété est définie sur true pour tous les utilisateurs. Cela signifie que les autorisations définies dans Lake Formation s'appliquent à l'emplacement enregistré. La vente des accréditations sera effectuée par Lake Formation. |
| Mode d'accès hybride | Inscrit | True | Pour les utilisateurs qui ont choisi d'utiliser Lake Formation pour l'accès aux données et la gouvernance d'une table, la `IsRegisteredWithLakeFormation` propriété sera définie sur `true` pour cette table. Ils sont soumis aux politiques d'autorisation définies dans Lake Formation pour le site enregistré. |
| Mode d'accès hybride | Non inscrit | False | Pour les utilisateurs qui n'ont pas choisi d'utiliser les autorisations de Lake Formation, la `IsRegisteredWithLakeFormation` propriété est définie sur`false`. Ils ne sont pas soumis aux politiques d'autorisation définies dans Lake Formation pour le site enregistré. Les utilisateurs suivront plutôt les politiques d'autorisation d'Amazon S3. |
# Conversion d'une AWS Glue ressource en ressource hybride
Suivez ces étapes pour enregistrer un site Amazon S3 en mode d'accès hybride et intégrer de nouveaux utilisateurs de Lake Formation sans interrompre l'accès aux données des utilisateurs existants du catalogue de données.
Description du scénario - L'emplacement des données n'est pas enregistré auprès de Lake Formation, et l'accès des utilisateurs à la base de données et aux tables du catalogue de données est déterminé par les politiques d'autorisation IAM pour Amazon S3 et AWS Glue les actions.
Le `IAMAllowedPrincipals` groupe dispose par défaut d'`Super`autorisations sur toutes les tables de la base de données.
**Pour activer le mode d'accès hybride pour un emplacement de données non enregistré auprès de Lake Formation**
1.
**Enregistrez un emplacement Amazon S3 permettant le mode d'accès hybride.**
------
#### [ Console ]
1. Connectez-vous à la [console Lake Formation](https://console.aws.amazon.com/lakeformation/) en tant qu'administrateur du lac de données.
1. Dans le volet de navigation, sélectionnez **Emplacements des lacs de données** sous **Administration**.
1. Choisissez **Enregistrer l'emplacement**.
![\[Register location form for Amazon S3 data lake with path input, IAM role selection, and permission mode options.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/hybrid-access-register-s3.png)
1. Dans la fenêtre **Enregistrer l'emplacement**, choisissez le chemin **Amazon S3** que vous souhaitez enregistrer auprès de Lake Formation.
1. Pour le **rôle IAM**, choisissez le rôle `AWSServiceRoleForLakeFormationDataAccess` lié au service (par défaut) ou un rôle IAM personnalisé rôle qui répond aux exigences de[Exigences relatives aux rôles utilisés pour enregistrer des sites](registration-role.md).
1. Choisissez le **mode d'accès hybride** pour appliquer des politiques précises de contrôle d'accès à Lake Formation aux principes d'adhésion ainsi qu'aux bases de données et aux tables du catalogue de données pointant vers l'emplacement enregistré.
Choisissez Lake Formation pour permettre à Lake Formation d'autoriser les demandes d'accès à l'emplacement enregistré.
1. Choisissez **Enregistrer l'emplacement**.
------
#### [ AWS CLI ]
Voici un exemple d'enregistrement d'un emplacement de données auprès de Lake Formation HybridAccessEnabled avec:true/false. La valeur par défaut du `HybridAccessEnabled` paramètre est false. Remplacez le chemin, le nom du rôle et l'identifiant du AWS compte Amazon S3 par des valeurs valides.
```
aws lakeformation register-resource --cli-input-json file:file path
json:
{
"ResourceArn": "arn:aws:s3:::s3-path",
"UseServiceLinkedRole": false,
"RoleArn": "arn:aws:iam::<123456789012>:role/",
"HybridAccessEnabled": true
}
```
------
1.
**Accordez des autorisations et autorisez les principaux à utiliser les autorisations de Lake Formation pour les ressources en mode d'accès hybride**
Avant d'activer les principes et les ressources en mode d'accès hybride, vérifiez que les bases de données et les tables dont l'emplacement est enregistré auprès de Lake Formation en mode d'accès hybride existent `Super` ou que les `All` autorisations de `IAMAllowedPrincipals` regroupement existent.
**Note**
Vous ne pouvez pas accorder d'autorisation au `IAMAllowedPrincipals` groupe `All tables` dans une base de données. Vous devez sélectionner chaque table séparément dans le menu déroulant et accorder des autorisations. En outre, lorsque vous créez de nouvelles tables dans la base de données, vous pouvez choisir de les utiliser `Use only IAM access control for new tables in new databases` dans les **paramètres du catalogue de données**. Cette option accorde automatiquement `Super` l'autorisation au `IAMAllowedPrincipals` groupe lorsque vous créez de nouvelles tables dans la base de données.
------
#### [ Console ]
1. Sur la console Lake Formation, sous **Data Catalog**, sélectionnez **Catalogues, **Databases**** ou **Tables**.
1. Sélectionnez un catalogue, une base de données ou une table dans la liste, puis choisissez **Grant** dans le menu **Actions**.
1. Choisissez des principes pour accorder des autorisations sur la base de données, les tables et les colonnes à l'aide d'une méthode de ressource nommée ou de balises LF.
Vous pouvez également choisir **Autorisations relatives aux données**, sélectionner les principaux auxquels accorder les autorisations dans la liste, puis sélectionner **Accorder**.
Pour plus de détails sur l'octroi d'autorisations de données, consultez[Octroi d'autorisations sur les ressources du catalogue de données](granting-catalog-permissions.md).
**Note**
Si vous accordez à un principal l'autorisation de créer une table, vous devez également accorder des autorisations de localisation des données (`DATA_LOCATION_ACCESS`) au principal. Cette autorisation n'est pas nécessaire pour mettre à jour les tables.
Pour de plus amples informations, veuillez consulter [Octroi d'autorisations de localisation des données](granting-location-permissions.md).
1. Lorsque vous utilisez la **méthode des ressources nommées** pour accorder des autorisations, l'option permettant d'activer les principes et les ressources est disponible dans la section inférieure de la page d'**autorisation des données d'octroi**.
Choisissez **Rendre les autorisations Lake Formation effectives immédiatement** pour activer les autorisations Lake Formation pour les principaux et les ressources.
![\[L'option permettant de choisir le mode d'accès hybride pour la ressource du catalogue de données.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/hybrid-access-grant-option.png)
1. Choisissez **Accorder**.
Lorsque vous activez le principal A sur la table A qui pointe vers un emplacement de données, cela permet au principal A d'accéder à l'emplacement de cette table en utilisant les autorisations de Lake Formation si l'emplacement des données est enregistré en mode hybride.
------
#### [ AWS CLI ]
Voici un exemple d'activation d'un principal et d'une table en mode d'accès hybride. Remplacez le nom du rôle, l'identifiant du AWS compte, le nom de la base de données et le nom de la table par des valeurs valides.
```
aws lakeformation create-lake-formation-opt-in --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam::<123456789012>:role/"
},
"Resource": {
"Table": {
"CatalogId": "<123456789012>",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
1. Si vous choisissez les balises LF pour octroyer des autorisations, vous pouvez activer les principes pour utiliser les autorisations de Lake Formation lors d'une étape séparée. Vous pouvez le faire en choisissant le **mode d'accès hybride** sous **Autorisations** dans la barre de navigation de gauche.
1. Dans la section inférieure de la page du **mode d'accès hybride**, choisissez **Ajouter pour ajouter** des ressources et des principes au mode d'accès hybride.
1. Sur la page **Ajouter des ressources et des principes**, choisissez les catalogues, les bases de données et les tables enregistrés en mode d'accès hybride.
Vous pouvez choisir d'autoriser l'accès `All tables` dans une base de données.
![\[Interface permettant d'ajouter des catalogues, des bases de données et des tables en mode d'accès hybride.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/hybrid-access-opt-in.png)
1. Choisissez les principaux et acceptez d'utiliser les autorisations de Lake Formation en mode d'accès hybride.
+ **Principaux** — Vous pouvez choisir les utilisateurs et les rôles IAM dans le même compte ou dans un autre compte. Vous pouvez également choisir des utilisateurs et des groupes SAML.
+ **Attributs** : sélectionnez les attributs pour accorder des autorisations en fonction des attributs.
![\[Interface permettant d'ajouter des principes et des ressources avec une expression d'attribut.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/abac-hybrid-access.png)
+ Entrez la paire clé-valeur pour créer une subvention basée sur les attributs. Passez en revue l'expression de politique Cedar sur la console. Pour plus d'informations sur le cèdre, voir [Qu'est-ce que le cèdre ? \$1 Référence linguistique des politiques de Cedar GuideLink](https://docs.cedarpolicy.com/).
+ Choisissez **Ajouter**.
L'accès est accordé à tous roles/users les IAM dont les attributs correspondent.
1. Choisissez **Ajouter**.
# Conversion d'une ressource de la Lake Formation en une ressource hybride
Dans les cas où vous utilisez actuellement les autorisations Lake Formation pour les bases de données et les tables de votre catalogue de données, vous pouvez modifier les propriétés d'enregistrement des emplacements pour activer le mode d'accès hybride. Cela vous permet de fournir aux nouveaux principaux l'accès aux mêmes ressources en utilisant les politiques d'autorisation IAM pour Amazon S3 et les AWS Glue actions sans interrompre les autorisations Lake Formation existantes.
Description du scénario - Les étapes suivantes supposent que vous avez un emplacement de données enregistré auprès de Lake Formation et que vous avez défini des autorisations pour les principaux sur les bases de données, les tables ou les colonnes pointant vers cet emplacement. Si l'emplacement a été enregistré avec un rôle lié à un service, vous ne pouvez pas mettre à jour les paramètres de localisation et activer le mode d'accès hybride. Le `IAMAllowedPrincipals` groupe dispose par défaut de super autorisations sur la base de données et toutes ses tables.
**Important**
Ne mettez pas à jour l'enregistrement d'un emplacement en mode d'accès hybride sans avoir sélectionné les principaux utilisateurs qui accèdent aux données dans cet emplacement.
**Activation du mode d'accès hybride pour un emplacement de données enregistré auprès de Lake Formation**
1.
**Avertissement**
Nous ne recommandons pas de convertir un emplacement de données géré par Lake Formation en mode d'accès hybride pour éviter d'interrompre les politiques d'autorisation des autres utilisateurs ou charges de travail existants.
Ajoutez les principaux existants qui ont les autorisations de Lake Formation.
1. Répertoriez et passez en revue les autorisations que vous avez accordées aux principaux sur les catalogues, les bases de données et les tables. Pour de plus amples informations, veuillez consulter [Affichage des autorisations de base de données et de tables dans Lake Formation](viewing-permissions.md).
1. Choisissez le **mode d'accès hybride** sous **Autorisations** dans la barre de navigation de gauche, puis choisissez **Ajouter**.
1. Sur la page **Ajouter des principes et des ressources**, choisissez les catalogues, les bases de données et les tables de l'emplacement de données Amazon S3 que vous souhaitez utiliser en mode d'accès hybride. Choisissez les principaux qui disposent déjà des autorisations de Lake Formation.
1. Choisissez **Ajouter** pour activer les principes permettant d'utiliser les autorisations de Lake Formation en mode d'accès hybride.
1. Mettez à jour l' bucket/prefix enregistrement Amazon S3 en choisissant l'option **Mode d'accès hybride**.
------
#### [ Console ]
1. Connectez-vous à la console Lake Formation en tant qu'administrateur du lac de données.
1. Dans le volet de navigation, sous **Enregistrer et ingérer**, sélectionnez **Data lake locations**.
1. Sélectionnez un emplacement, puis dans le menu **Actions**, choisissez **Modifier**.
1. Choisissez le **mode d'accès hybride**.
1. Choisissez **Enregistrer**.
1. Sous Catalogue de données, sélectionnez la base de données ou la table et accordez `Super` `All` des autorisations au groupe virtuel appelé`IAMAllowedPrincipals`.
1. Vérifiez que l'accès de vos utilisateurs actuels de Lake Formation n'est pas interrompu lorsque vous avez mis à jour les propriétés d'enregistrement de la localisation. Connectez-vous à la console Athena en tant que responsable de Lake Formation et exécutez un exemple de requête sur une table pointant vers l'emplacement mis à jour.
De même, vérifiez l'accès des AWS Glue utilisateurs qui utilisent les politiques d'autorisation IAM pour accéder à la base de données et aux tables.
------
#### [ AWS CLI ]
Voici un exemple d'enregistrement d'un emplacement de données auprès de Lake Formation HybridAccessEnabled avec:true/false. La valeur par défaut du `HybridAccessEnabled` paramètre est false. Remplacez le chemin, le nom du rôle et l'identifiant du AWS compte Amazon S3 par des valeurs valides.
```
aws lakeformation update-resource --cli-input-json file://file path
json:
{
"ResourceArn": "arn:aws:s3:::",
"RoleArn": "arn:aws:iam::<123456789012>:role/",
"HybridAccessEnabled": true
}
```
------
# Partage d'une AWS Glue ressource à l'aide du mode d'accès hybride
Partagez des données avec une autre personne Compte AWS ou un responsable d'un autre en Compte AWS appliquant les autorisations de Lake Formation sans interrompre l'accès basé sur l'IAM des utilisateurs existants du catalogue de données.
Description du scénario - Le compte producteur dispose d'une base de données de catalogue de données dont l'accès est contrôlé à l'aide des principales politiques et AWS Glue actions IAM pour Amazon S3. L'emplacement des données de la base de données n'est pas enregistré auprès de Lake Formation. Le `IAMAllowedPrincipals` groupe dispose par défaut d'`Super`autorisations sur la base de données et sur toutes ses tables.
**Octroi d'autorisations entre comptes Lake Formation en mode d'accès hybride**
1.
**Configuration du compte producteur**
1. Connectez-vous à la console Lake Formation à l'aide d'un rôle autorisé par `lakeformation:PutDataLakeSettings` IAM.
1. Accédez aux **paramètres du catalogue de données** et choisissez `Version 4` les **paramètres de version entre comptes**.
Si vous utilisez actuellement la version 1 ou 2, consultez [Mise à jour des paramètres de version de partage de données entre comptes](optimize-ram.md) les instructions relatives à la mise à jour vers la version 3.
Aucune modification de la politique d'autorisation n'est requise lors de la mise à niveau de la version 3 vers la version 4.
1. Enregistrez l'emplacement Amazon S3 de la base de données ou de la table que vous prévoyez de partager en mode d'accès hybride.
1. Vérifiez que l'`Super`autorisation d'accès au `IAMAllowedPrincipals` groupe existe sur les bases de données et les tables dont vous avez enregistré l'emplacement des données en mode d'accès hybride à l'étape ci-dessus.
1. Accordez des autorisations Lake Formation à AWS des organisations, à des unités organisationnelles (OUs) ou directement auprès d'un directeur IAM sur un autre compte.
1. Si vous accordez des autorisations directement à un directeur IAM, activez le principal depuis le compte client pour appliquer les autorisations Lake Formation en mode d'accès hybride en activant l'option **Rendre les autorisations Lake Formation effectives immédiatement**.
Si vous accordez des autorisations entre comptes à un autre AWS compte, lorsque vous activez le compte, les autorisations de Lake Formation ne sont appliquées qu'aux administrateurs de ce compte. L'administrateur du lac de données du compte destinataire doit répartir les autorisations en cascade et sélectionner les principaux du compte pour appliquer les autorisations de Lake Formation aux ressources partagées en mode d'accès hybride.
Si vous choisissez l'option **Ressources correspondant à des balises LF** pour accorder des autorisations entre comptes, vous devez d'abord terminer l'étape d'octroi des autorisations. Vous pouvez activer les principes et les ressources pour le mode d'accès hybride lors d'une étape séparée en choisissant le **mode d'accès hybride** sous Autorisations dans la barre de navigation de gauche de la console Lake Formation. Choisissez ensuite **Ajouter** pour ajouter les ressources et les principes auxquels vous souhaitez appliquer les autorisations de Lake Formation.
1.
**Configuration du compte client**
1. Connectez-vous à la console Lake Formation en [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)tant qu'administrateur de lac de données.
1. Rentrez [https://console.aws.amazon.com/ram/chez](https://console.aws.amazon.com/ram/home) vous et acceptez l'invitation de partage de ressources. L'onglet **Partagé avec moi** de la AWS RAM console affiche la base de données et les tables partagées avec votre compte.
1. Créez un lien de ressource vers la and/or table de base de données partagée dans Lake Formation.
1. Accordez `Describe` l'autorisation sur le lien vers la ressource et l'`Grant on target`autorisation (sur la ressource partagée d'origine) aux responsables IAM de votre compte (consommateur).
1. Accordez aux responsables de votre compte des autorisations sur la base de données ou la table partagée avec vous à Lake Formation. Choisissez les principes et les ressources nécessaires pour appliquer les autorisations de Lake Formation en mode d'accès hybride en activant l'option **Rendre les autorisations Lake Formation effectives immédiatement**.
1. Testez les autorisations du principal sur la Lake Formation en exécutant des exemples de requêtes Athena. Testez l'accès existant de vos AWS Glue utilisateurs à l'aide des principales politiques et AWS Glue actions IAM pour Amazon S3.
(Facultatif) Supprimez la politique de compartiment Amazon S3 pour l'accès aux données et les politiques principales IAM AWS Glue et d'accès aux données Amazon S3 pour les principaux que vous avez configurés pour utiliser les autorisations de Lake Formation.
# Partage d'une ressource de Lake Formation à l'aide du mode d'accès hybride
Autorisez les nouveaux utilisateurs du catalogue de données d'un compte externe à accéder aux bases de données et aux tables du catalogue de données à l'aide de politiques basées sur l'IAM sans interrompre les autorisations de partage entre comptes existantes de Lake Formation.
Description du scénario - Le compte producteur possède une base de données gérée par Lake Formation et des tables partagées avec un compte externe (consommateur) au niveau du compte ou au niveau principal de l'IAM. L'emplacement des données de la base de données est enregistré auprès de Lake Formation. Le `IAMAllowedPrincipals` groupe ne dispose pas d'`Super`autorisations sur la base de données et ses tables.
**Accorder un accès multicompte aux nouveaux utilisateurs du catalogue de données via des politiques basées sur l'IAM sans interrompre les autorisations existantes de Lake Formation**
1.
**Configuration du compte producteur**
1. Connectez-vous à la console Lake Formation en utilisant un rôle qui`lakeformation:PutDataLakeSettings`.
1. Sous **Paramètres du catalogue de données**, choisissez `Version 4` les **paramètres de version multi-comptes**.
Si vous utilisez actuellement la version 1 ou 2, consultez [Mise à jour des paramètres de version de partage de données entre comptes](optimize-ram.md) les instructions relatives à la mise à jour vers la version 3.
Aucune modification de la politique d'autorisation n'est requise pour passer de la version 3 à la version 4.
1. Répertoriez les autorisations que vous avez accordées aux principaux sur les bases de données et les tables. Pour de plus amples informations, veuillez consulter [Affichage des autorisations de base de données et de tables dans Lake Formation](viewing-permissions.md).
1. Réaccordez les autorisations de comptes croisées de Lake Formation existantes en optant pour les principes et les ressources.
**Note**
Avant de mettre à jour un enregistrement de localisation de données en mode d'accès hybride afin d'accorder des autorisations entre comptes, vous devez réaccorder au moins un partage de données entre comptes par compte. Cette étape est nécessaire pour mettre à jour les autorisations AWS RAM gérées associées au partage de AWS RAM ressources.
En juillet 2023, Lake Formation a mis à jour les autorisations AWS RAM gérées utilisées pour le partage de bases de données et de tables :
`arn:aws:ram::aws:permission/AWSRAMLFEnabledGlueAllTablesReadWriteForDatabase`(politique de partage au niveau de la base de données)
`arn:aws:ram::aws:permission/AWSRAMLFEnabledGlueTableReadWrite`(politique de partage au niveau de la table)
Les autorisations entre comptes accordées avant juillet 2023 ne sont pas assorties de ces AWS RAM autorisations mises à jour.
Si vous avez accordé des autorisations multi-comptes directement aux principaux, vous devez les accorder de nouveau individuellement aux principaux. Si vous ignorez cette étape, les principaux accédant à la ressource partagée risquent de recevoir une erreur de combinaison illégale.
1. Rentre [https://console.aws.amazon.com/ram/chez toi](https://console.aws.amazon.com/ram/home).
1. L'onglet **Shared by me** de la AWS RAM console affiche les noms de base de données et de tables que vous avez partagés avec un compte ou un principal externe.
Assurez-vous que les autorisations associées à la ressource partagée possèdent le bon ARN.
1. Vérifiez que le `Associated` statut des ressources du AWS RAM partage est valide. Si le statut est défini comme tel`Associating`, attendez qu'ils passent à `Associated` l'état. Si le statut devient le même`Failed`, arrêtez-vous et contactez l'équipe de service de Lake Formation.
1. Choisissez le **mode d'accès hybride** sous **Autorisations** dans la barre de navigation de gauche, puis choisissez **Ajouter**.
1. La page **Ajouter des principes et des ressources** indique les bases de données, and/or les tables et les principes auxquels ils ont accès. Vous pouvez effectuer les mises à jour requises en ajoutant ou en supprimant des principes et des ressources.
1. Choisissez les principes dotés des autorisations Lake Formation pour la base de données et les tables que vous souhaitez passer en mode d'accès hybride. Choisissez les bases de données et les tables.
1. Choisissez **Ajouter** pour activer les principes permettant d'appliquer les autorisations de Lake Formation en mode d'accès hybride.
1. Accordez l'`Super`autorisation au groupe virtuel `IAMAllowedPrincipals` sur votre base de données et sur les tables sélectionnées.
1. Modifiez l'enregistrement du site Amazon S3 Lake Formation en mode d'accès hybride.
1. Accordez des autorisations aux AWS Glue utilisateurs du compte externe (consommateur) en utilisant les politiques d'autorisation IAM pour les AWS Glue actions Amazon S3.
1.
**Configuration du compte client**
1. Connectez-vous à la console Lake Formation en [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)tant qu'administrateur de lac de données.
1. Accédez à la [https://console.aws.amazon.com/ram/page d'accueil](https://console.aws.amazon.com/ram/home) et acceptez l'invitation de partage de ressources. L'onglet **Ressources partagées avec moi** de la AWS RAM page affiche les noms de base de données et de tables partagés avec votre compte.
Pour le AWS RAM partage, assurez-vous que l'autorisation attachée possède le bon ARN de l' AWS RAM invitation partagée. Vérifiez si les ressources du AWS RAM partage sont en `Associated` état. Si le statut est défini comme tel`Associating`, attendez qu'ils passent à `Associated` l'état. Si le statut devient le même`Failed`, arrêtez-vous et contactez l'équipe de service de Lake Formation.
1. Créez un lien de ressource vers la and/or table de base de données partagée dans Lake Formation.
1. Accordez `Describe` l'autorisation sur le lien vers la ressource et l'`Grant on target`autorisation (sur la ressource partagée d'origine) aux responsables IAM de votre compte (consommateur).
1. Configurez ensuite les autorisations de Lake Formation pour les principaux utilisateurs de votre compte sur la base de données ou la table partagée.
Dans la barre de navigation de gauche, sous **Autorisations**, choisissez le **mode d'accès hybride**.
1. Choisissez **Ajouter** dans la section inférieure de la page du **mode d'accès hybride** pour activer les principes et la base de données ou la table partagée avec vous depuis le compte du producteur.
1. Accordez des autorisations aux AWS Glue utilisateurs de votre compte en utilisant les politiques d'autorisation IAM pour les AWS Glue actions Amazon S3.
1. Testez les autorisations et AWS Glue autorisations des utilisateurs de Lake Formation en exécutant des exemples de requêtes distincts sur la table à l'aide d'Athena
(Facultatif) Nettoyez les politiques d'autorisation IAM pour Amazon S3 pour les principaux qui sont en mode d'accès hybride.
# Supprimer les principes et les ressources du mode d'accès hybride
Procédez comme suit pour supprimer les bases de données, les tables et les principes du mode d'accès hybride.
------
#### [ Console ]
1. Connectez-vous à la console Lake Formation à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Sous **Autorisations**, choisissez le **mode d'accès hybride**.
1. Sur la page **Mode d'accès hybride**, cochez la case à côté du nom de la base de données ou de la table et choisissez`Remove`.
1. Un message d'avertissement vous invite à confirmer l'action. Cliquez sur **Supprimer**.
Lake Formation n'applique plus les autorisations pour ces ressources, et l'accès à ces ressources sera contrôlé à l'aide de l'IAM et AWS Glue des autorisations. Cela peut empêcher l'utilisateur d'avoir accès à cette ressource s'il ne dispose pas des autorisations IAM appropriées.
------
#### [ AWS CLI ]
L'exemple suivant montre comment supprimer des ressources du mode d'accès hybride.
```
aws lakeformation delete-lake-formation-opt-in --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam::<123456789012>:role/role name"
},
"Resource": {
"Table": {
"CatalogId": "<123456789012>",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
# Affichage des principes et des ressources en mode d'accès hybride
Procédez comme suit pour afficher les bases de données, les tables et les principaux en mode d'accès hybride.
------
#### [ Console ]
1. Connectez-vous à la console Lake Formation à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Sous **Autorisations**, choisissez le **mode d'accès hybride**.
1. La page **Mode d'accès hybride** affiche les ressources et les principaux qui sont actuellement en mode d'accès hybride.
------
#### [ AWS CLI ]
L'exemple suivant montre comment répertorier tous les principes et ressources optionnels en mode d'accès hybride.
```
aws lakeformation list-lake-formation-opt-ins
```
L'exemple suivant montre comment répertorier l'opt-in pour une paire principale-ressource spécifique.
```
aws lakeformation list-lake-formation-opt-ins --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam:::role/"
},
"Resource": {
"Table": {
"CatalogId": "",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
# Ressources supplémentaires
Dans le billet de blog suivant, nous vous expliquons comment intégrer les autorisations Lake Formation en mode d'accès hybride pour certains utilisateurs alors que la base de données est déjà accessible aux autres utilisateurs via les autorisations IAM et Amazon S3. Nous passerons en revue les instructions pour configurer le mode d'accès hybride au sein d'un AWS compte et entre deux comptes.
+ [Présentation du mode d'accès hybride pour sécuriser l'accès AWS Glue Data Catalog à l'aide de Lake Formation et des politiques IAM et Amazon S3.](https://aws.amazon.com/blogs/big-data/introducing-hybrid-access-mode-for-aws-glue-data-catalog-to-secure-access-using-aws-lake-formation-and-iam-and-amazon-s3-policies/)
# Création d'objets dans AWS Glue Data Catalog
AWS Lake Formation utilise le AWS Glue Data Catalog (catalogue de données) pour stocker les métadonnées relatives aux lacs de données, aux sources de données, aux transformations et aux cibles. Les métadonnées sont des données relatives aux données sous-jacentes de votre jeu de données. Chaque AWS compte possède un catalogue de données par AWS région.
Les métadonnées du catalogue de données sont organisées selon une hiérarchie de données à trois niveaux comprenant des catalogues, des bases de données et des tables. Il organise les données provenant de diverses sources dans des conteneurs logiques appelés catalogues. Chaque catalogue représente des données provenant de sources telles que les entrepôts de données Amazon Redshift, les Amazon DynamoDB bases de données et les sources de données tierces telles que Snowflake, MySQL, et de plus de 30 sources de données externes, qui sont intégrées via des connecteurs fédérés. Vous pouvez également créer de nouveaux catalogues dans le catalogue de données pour stocker les données dans des compartiments de table S3 ou dans le stockage géré Redshift (RMS).
Les tables stockent des informations sur les données sous-jacentes, notamment les informations de schéma, les informations de partition et l'emplacement des données. Les bases de données sont des ensembles de tables. Le catalogue de données contient également des liens vers des ressources, qui sont des liens vers des catalogues, des bases de données et des tables partagés dans des comptes externes, et sont utilisés pour l'accès entre comptes aux données du lac de données.
Le catalogue de données est un objet de catalogue imbriqué qui contient des catalogues, des bases de données et des tables. Il est référencé par l' Compte AWS ID et constitue le catalogue par défaut d'un compte et d'un Région AWS. Le catalogue de données utilise une hiérarchie à trois niveaux (catalog.database.table) pour organiser les tables.
+ Catalogue : niveau supérieur de la hiérarchie des métadonnées à trois niveaux du catalogue de données. Vous pouvez ajouter plusieurs catalogues dans un catalogue de données par le biais de la fédération.
+ Base de données : deuxième niveau de la hiérarchie des métadonnées comprenant des tables et des vues. Une base de données est également appelée schéma dans de nombreux systèmes de données tels qu'Amazon Redshift et Trino.
+ Tableau et affichage : troisième niveau de la hiérarchie des données à 3 niveaux du catalogue de données.
Toutes les tables Iceberg d'Amazon S3 sont stockées dans le catalogue de données par défaut avec Catalog ID = Compte AWS ID. Vous pouvez créer des catalogues fédérés dans lesquels sont stockées AWS Glue Data Catalog les définitions des tables dans Amazon Redshift, Amazon S3 Table Storage ou dans d'autres sources de données tierces par le biais de la fédération.
**Topics**
+ [Création d'un catalogue](creating-catalog.md)
+ [Création d’une base de données](creating-database.md)
+ [Création de tables](creating-tables.md)
+ [AWS Glue Data Catalog Vues du bâtiment](working-with-views.md)
# Création d'un catalogue
Les catalogues représentent le niveau le plus élevé ou le plus élevé de la hiérarchie de métadonnées à trois niveaux du. AWS Glue Data Catalog Vous pouvez utiliser plusieurs méthodes pour intégrer des données dans le catalogue de données et créer des catalogues à plusieurs niveaux.
Pour plus d'informations sur la création de catalogues à partir de sources de données externes, consultez[Intégrer vos données dans AWS Glue Data Catalog](bring-your-data-overview.md).
Pour créer un catalogue à l'aide de la console Lake Formation, vous devez être connecté en tant qu'administrateur de lac de données ou *créateur de catalogue*. Un créateur de catalogue est un directeur qui a obtenu l'`CREATE_CATALOG`autorisation de Lake Formation. Vous pouvez consulter la liste des créateurs de catalogues sur la page **Rôles et tâches administratifs** de la console Lake Formation. Pour consulter cette liste, vous devez disposer de l'autorisation `lakeformation:ListPermissions` IAM et être connecté en tant qu'administrateur de lac de données ou en tant que créateur de catalogue avec l'option d'octroi sur l'`CREATE_CATALOG`autorisation.
# Création d’une base de données
Les tables de métadonnées du catalogue de données sont stockées dans des bases de données. Vous pouvez créer autant de bases de données que vous le souhaitez, et vous pouvez accorder différentes autorisations Lake Formation pour chaque base de données.
Les bases de données peuvent avoir une propriété d'emplacement facultative. Cet emplacement se trouve généralement dans un site Amazon Simple Storage Service (Amazon S3) enregistré auprès de Lake Formation. Lorsque vous spécifiez un emplacement, les principaux n'ont pas besoin d'autorisations de localisation des données pour créer des tables de catalogue de données qui pointent vers des emplacements au sein de l'emplacement de la base de données. Pour de plus amples informations, veuillez consulter [Underlying data access control](access-control-underlying-data.md#data-location-permissions).
Pour créer une base de données à l'aide de la console Lake Formation, vous devez être connecté en tant qu'administrateur de lac de données ou *créateur de base de données*. Un créateur de base de données est un directeur qui a obtenu l'`CREATE_DATABASE`autorisation de Lake Formation. Vous pouvez consulter la liste des créateurs de bases de données sur la page **Rôles et tâches administratifs** de la console Lake Formation. Pour consulter cette liste, vous devez disposer de l'autorisation `lakeformation:ListPermissions` IAM et être connecté en tant qu'administrateur de lac de données ou en tant que créateur de base de données avec l'option d'octroi sur l'`CREATE_DATABASE`autorisation.
**Pour créer une base de données**
1. Ouvrez la AWS Lake Formation console sur [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)et connectez-vous en tant qu'administrateur de lac de données ou créateur de base de données.
1. Dans le volet de navigation, sous **Catalogue de données**, sélectionnez **Bases de données**.
1. Choisissez **Créer une base de données**.
1. Dans la boîte **de dialogue Créer une base** de données, entrez un nom de base de données, un emplacement facultatif et une description facultative.
1. Sélectionnez éventuellement **Utiliser uniquement le contrôle d'accès IAM pour les nouvelles tables de cette base de données**.
Pour de plus amples informations sur cette option, veuillez consulter [Modification des paramètres par défaut de votre lac de données](change-settings.md).
1. Choisissez **Créer une base de données**.
# Création de tables
AWS Lake Formation les tables de métadonnées contiennent des informations sur les données du lac de données, notamment des informations sur le schéma, les informations de partition et l'emplacement des données. Ces tables sont stockées dans le catalogue AWS Glue de données. Vous les utilisez pour accéder aux données sous-jacentes du lac de données et pour gérer ces données avec les autorisations de Lake Formation. Les tables sont stockées dans les bases de données du catalogue de données.
Il existe plusieurs méthodes pour créer des tables de catalogue de données :
+ Lancez un crawler dedans. AWS Glue Consultez [la section Définition des robots](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) d'exploration dans le *guide du AWS Glue développeur*.
+ Créez et exécutez un flux de travail. Consultez [Importation de données à l'aide de flux de travail dans Lake Formation](workflows.md).
+ Créez une table manuellement à l'aide de la console Lake Formation, de AWS Glue l'API ou AWS Command Line Interface (AWS CLI).
+ Créez un tableau à l'aide de Amazon Athena.
+ Créez un lien de ressource vers une table dans un compte externe. Consultez [Création de liens vers des ressources](creating-resource-links.md).
# Création de tables Apache Iceberg
AWS Lake Formation prend en charge la création de tables Apache Iceberg qui utilisent le format de données Apache Parquet dans AWS Glue Data Catalog les données résidant dans Amazon S3. Une table dans le catalogue de données correspond à la définition des métadonnées qui représente les données dans un entrepôt de données. Par défaut, Lake Formation crée des tables Iceberg v2. Pour connaître la différence entre les tables v1 et v2, consultez la section [Modifications de version de format](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) dans la documentation Apache Iceberg.
[Apache Iceberg](https://iceberg.apache.org/) est un format de table ouvert pour les jeux de données analytiques très volumineux. Iceberg permet de modifier facilement votre schéma, également ce que l’on appelle l’évolution du schéma, ce qui signifie que les utilisateurs peuvent ajouter, renommer ou supprimer des colonnes d’une table de données sans perturber les données sous-jacentes. Iceberg fournit également une prise en charge pour la gestion des versions des données, ce qui permet aux utilisateurs de suivre les modifications apportées aux données au fil du temps. Cela active la fonctionnalité Time Travel, qui permet aux utilisateurs d’accéder aux versions historiques des données, de les interroger, mais aussi d’analyser les modifications apportées aux données entre les mises à jour et les suppressions.
Vous pouvez utiliser la console Lake Formation ou l'`CreateTable`opération de l' AWS Glue API pour créer une table Iceberg dans le catalogue de données. Pour plus d'informations, consultez [CreateTable action (Python : create\$1table](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-CreateTable)).
Lorsque vous créez une table Iceberg dans le catalogue de données, vous devez spécifier le format de la table et le chemin d’accès au fichier de métadonnées dans Amazon S3 pour pouvoir effectuer des lectures et des écritures.
Vous pouvez utiliser Lake Formation pour sécuriser votre table Iceberg à l'aide d'autorisations de contrôle d'accès précises lorsque vous enregistrez l'emplacement des données Amazon S3 auprès de celui-ci. AWS Lake Formation Pour les données source dans Amazon S3 et les métadonnées qui ne sont pas enregistrées auprès de Lake Formation, l'accès est déterminé par les politiques d'autorisation IAM pour Amazon S3 et AWS Glue les actions. Pour de plus amples informations, veuillez consulter [Gestion des autorisations relatives à Lake Formation](managing-permissions.md).
**Note**
Le catalogue de données ne prend pas en charge la création de partitions ni l’ajout de propriétés de table Iceberg.
**Topics**
+ [Conditions préalables](#iceberg-prerequisites)
+ [Création d’une table Iceberg](#create-iceberg-table)
## Conditions préalables
Pour créer des tables Iceberg dans le catalogue de données et configurer les autorisations d’accès aux données de Lake Formation, vous devez remplir les conditions suivantes :
1.
**Autorisations requises pour créer des tables Iceberg sans les données enregistrées auprès de Lake Formation :**
Outre les autorisations requises pour créer une table dans le catalogue de données, le créateur de table exige les autorisations suivantes :
+ `s3:PutObject` sur la ressource arn:aws:s3:::\$1bucketName\$1
+ `s3:GetObject` sur la ressource arn:aws:s3:::\$1bucketName\$1
+ `s3:DeleteObject` sur la ressource arn:aws:s3:::\$1bucketName\$1
1.
**Autorisations requises pour créer des tables Iceberg avec des données enregistrées auprès de Lake Formation :**
Pour utiliser Lake Formation afin de gérer et de sécuriser les données de votre lac de données, enregistrez votre site Amazon S3 contenant les données pour les tables auprès de Lake Formation. Cela permet à Lake Formation de vendre des informations d'identification à AWS des services d'analyse tels qu'Athena, Redshift Spectrum et Amazon EMR pour accéder aux données. Pour plus d'informations sur l'enregistrement d'un site Amazon S3, consultez[Ajouter un emplacement Amazon S3 à votre lac de données](register-data-lake.md).
Un principal qui lit et écrit les données sous-jacentes enregistrées auprès de Lake Formation doit disposer des autorisations suivantes :
+ `lakeformation:GetDataAccess`
+ `DATA_LOCATION_ACCESS`
Un principal qui possède des autorisations de localisation des données sur un emplacement possède également des autorisations d’emplacement sur tous les sites enfant.
Pour plus d'informations sur les autorisations de localisation des données, consultez[Contrôle d'accès aux données sous-jacent](access-control-underlying-data.md).
Pour activer le compactage, le service doit endosser un rôle IAM autorisé à mettre à jour les tables dans le catalogue de données. Pour plus de détails, consultez la section [Conditions préalables à l'optimisation des tables](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html).
## Création d’une table Iceberg
Vous pouvez créer des tables Iceberg v1 et v2 à l'aide de la console Lake Formation ou AWS Command Line Interface comme indiqué sur cette page. Vous pouvez également créer des tables Iceberg à l'aide de AWS Glue la console ou AWS Glue crawler. Pour plus d’informations, consultez [Data Catalog and Crawlers](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) dans le Guide du développeur AWS Glue .
**Pour créer une table Iceberg**
------
#### [ Console ]
1. Connectez-vous à la AWS Management Console console Lake Formation et ouvrez-la à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Sous catalogue de données, choisissez **Tables**, puis utilisez le bouton **Créer une table** pour spécifier les attributs suivants :
+ **Nom de la table** : entrez le nom de la table. Si vous utilisez Athena pour accéder à des tables, utilisez ces [conseils de dénomination](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html) figurant dans le Guide de l’utilisateur Amazon Athena.
+ **Base de données** : Choisissez une base de données existante ou créez-en une nouvelle.
+ **Description : description de la** table. Vous pouvez écrire une description vous aidant à comprendre le contenu de la table.
+ **Format de tableau** : pour **Format de tableau**, choisissez Apache Iceberg.
![\[Option de table Apache Iceberg sélectionnée avec les options d'optimisation des tables.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/table-optimization.png)
+ **Optimisation des tables**
+ **Compactage** : les fichiers de données sont fusionnés et réécrits pour supprimer les données obsolètes et regrouper les données fragmentées dans des fichiers plus volumineux et plus efficaces.
+ **Conservation des instantanés** : les instantanés sont des versions horodatées d’une table Iceberg. Les configurations de conservation des instantanés permettent aux clients de définir la durée de conservation des instantanés et le nombre d’instantanés à conserver. La configuration d’un optimiseur de conservation des instantanés peut aider à gérer la charge de stockage en supprimant les instantanés plus anciens et inutiles, ainsi que leurs fichiers sous-jacents associés.
+ **Suppression de fichiers orphelins** : les fichiers orphelins sont des fichiers qui ne sont plus référencés par les métadonnées de la table Iceberg. Ces fichiers peuvent s’accumuler au fil du temps, en particulier après des opérations telles que la suppression de tables ou l’échec de tâches ETL. L'activation de la suppression des fichiers orphelins permet AWS Glue d'identifier et de supprimer périodiquement ces fichiers inutiles, libérant ainsi de l'espace de stockage.
Pour plus d’informations, consultez [Optimisation des tables Iceberg](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html).
+ **Rôle IAM** : pour exécuter le compactage, le service assume un rôle IAM en votre nom. Vous pouvez choisir un rôle IAM à l'aide de la liste déroulante. Assurez-vous que le rôle dispose des autorisations requises pour activer le compactage.
Pour en savoir plus sur les autorisations requises, consultez la section [Conditions préalables à l'optimisation des tables](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html).
+ **Emplacement** : Spécifiez le chemin d'accès au dossier dans Amazon S3 qui stocke la table de métadonnées. Iceberg a besoin d’un fichier de métadonnées et d’un emplacement dans le catalogue de données pour pouvoir effectuer des lectures et des écritures.
+ **Schéma** : choisissez **Ajouter des colonnes** pour ajouter des colonnes et les types de données des colonnes. Vous avez la possibilité de créer une table vide et de mettre à jour le schéma ultérieurement. Le catalogue de données prend en charge les types de données Hive. Pour plus d’informations, consultez [Hive data types](https://cwiki.apache.org/confluence/plugins/servlet/mobile?contentId=27838462#content/view/27838462).
Iceberg vous permet de faire évoluer le schéma et la partition après avoir créé la table. Vous pouvez utiliser des [requêtes Athena](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-evolving-table-schema.html) pour mettre à jour le schéma de table et des [requêtes Spark](https://iceberg.apache.org/docs/latest/spark-ddl/#alter-table-sql-extensions) pour mettre à jour les partitions.
------
#### [ AWS CLI ]
```
aws glue create-table \
--database-name iceberg-db \
--region us-west-2 \
--open-table-format-input '{
"IcebergInput": {
"MetadataOperation": "CREATE",
"Version": "2"
}
}' \
--table-input '{"Name":"test-iceberg-input-demo",
"TableType": "EXTERNAL_TABLE",
"StorageDescriptor":{
"Columns":[
{"Name":"col1", "Type":"int"},
{"Name":"col2", "Type":"int"},
{"Name":"col3", "Type":"string"}
],
"Location":"s3://DOC_EXAMPLE_BUCKET_ICEBERG/"
}
}'
```
------
# Optimisation des tables Iceberg
Lake Formation prend en charge plusieurs options d'optimisation des tables afin d'améliorer la gestion et les performances des tables Apache Iceberg utilisées par les moteurs AWS d'analyse et les tâches ETL. Ces optimiseurs permettent d’utiliser efficacement le stockage, d’améliorer les performances des requêtes et de gérer efficacement les données. Trois types d'optimiseurs de tables sont disponibles dans Lake Formation :
+ **Compactage** : le compactage des données compacte les petits fichiers de données afin de réduire l’utilisation du stockage et d’améliorer les performances de lecture. Les fichiers de données sont fusionnés et réécrits pour supprimer les données obsolètes et regrouper les données fragmentées dans des fichiers plus volumineux et plus efficaces. Le compactage peut être configuré pour s'exécuter automatiquement ou être déclenché manuellement selon les besoins.
+ **Conservation des instantanés** : les instantanés sont des versions horodatées d’une table Iceberg. Les configurations de conservation des instantanés permettent aux clients de définir la durée de conservation des instantanés et le nombre d’instantanés à conserver. La configuration d’un optimiseur de conservation des instantanés peut aider à gérer la charge de stockage en supprimant les instantanés plus anciens et inutiles, ainsi que leurs fichiers sous-jacents associés.
+ **Suppression de fichiers orphelins** : les fichiers orphelins sont des fichiers qui ne sont plus référencés par les métadonnées de la table Iceberg. Ces fichiers peuvent s’accumuler au fil du temps, en particulier après des opérations telles que la suppression de tables ou l’échec de tâches ETL. L'activation de la suppression des fichiers orphelins permet AWS Glue d'identifier et de supprimer périodiquement ces fichiers inutiles, libérant ainsi de l'espace de stockage.
Vous pouvez activer ou désactiver le compactage, la conservation des instantanés et les optimiseurs de suppression de fichiers orphelins pour les tables Iceberg individuelles du catalogue de données à l'aide de la AWS Glue console ou des opérations de l'API AWS CLI. AWS Glue
Pour plus d'informations, consultez la section [Optimisation des tables Iceberg](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html) dans le guide du AWS Glue développeur.
# Recherche de tables
Vous pouvez utiliser la AWS Lake Formation console pour rechercher des tables du catalogue de données par nom, emplacement, base de données contenant, etc. Les résultats de recherche n'affichent que les tables pour lesquelles vous êtes autorisé à accéder à Lake Formation.
**Pour rechercher des tables (console)**
1. Connectez-vous à la console Lake Formation AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans le volet de navigation, choisissez **Tables**.
1. Positionnez le curseur dans le champ de recherche en haut de la page. Le champ contient le texte d'espace réservé *Rechercher le tableau par propriétés*.
Le menu **Propriétés** apparaît et indique les différentes propriétés de table à partir desquelles effectuer une recherche.
![\[Le menu des propriétés est déroulant à partir du champ de recherche et contient les entrées suivantes : nom, classification, base de données, emplacement, numéro de catalogue\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/search-for-tables.png)
1. Effectuez l’une des actions suivantes :
+ Recherche par base de données contenant.
1. Choisissez **Base de données** dans le menu **Propriétés**, puis choisissez une base de données dans le menu **Bases** de données qui apparaît ou tapez un nom de base de données et appuyez sur **Entrée**.
Les tables sur lesquelles vous avez des autorisations dans la base de données sont répertoriées.
1. (Facultatif) Pour réduire la liste à une seule table de la base de données, positionnez à nouveau le curseur dans le champ de recherche, choisissez **Nom** dans le menu **Propriétés**, puis choisissez un nom de table dans le menu **Tables** qui apparaît ou tapez un nom de table et appuyez sur **Entrée**.
La table unique est répertoriée, et le nom de la base de données et le nom de la table apparaissent sous forme de vignettes sous le champ de recherche.
![\[Sous le champ de recherche se trouvent deux vignettes : l'une intitulée Base de données, qui inclut le nom de la base de données sélectionnée, et l'autre intitulée Table, qui inclut le nom de la table sélectionnée. À droite des vignettes se trouve un bouton Effacer le filtre.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/search-for-tables-with-filter.png)
Pour ajuster le filtre, fermez l'une des vignettes ou choisissez **Effacer le filtre**.
+ Effectuez une recherche par autres propriétés.
1. Choisissez une propriété de recherche dans le menu **Propriétés**.
**Pour effectuer une recherche par numéro de AWS compte, choisissez **Numéro de catalogue** dans le menu **Propriétés**, entrez un identifiant de AWS compte valide (par exemple, 111122223333), puis appuyez sur Entrée.**
Pour effectuer une recherche par lieu, choisissez **Emplacement** dans le menu **Propriétés**, puis sélectionnez un lieu **dans le menu Emplacements** qui apparaît. Toutes les tables situées à l'emplacement racine de l'emplacement sélectionné (par exemple, Amazon S3) sont renvoyées.
**Recherche de tables à l'aide de AWS CLI**
+ L'exemple suivant montre comment exécuter une recherche partielle. Le `--search-text` paramètre vous permet de rechercher des tables contenant le texte spécifié dans leurs métadonnées. Dans ce cas, il renvoie toutes les tables dont le nom, la description ou d'autres champs de métadonnées contiennent « client ».
```
aws glue search-tables
--search-text "customer"
--region Région AWS
--max-results 10
--sort-criteria "FieldName=Name,Sort=ASC"
```
# Partage des tables et des bases de données du catalogue de données entre les AWS comptes
Vous pouvez partager les ressources du catalogue de données (bases de données et tables) avec AWS des comptes externes en accordant à Lake Formation des autorisations sur les ressources aux comptes externes. Les utilisateurs peuvent ensuite exécuter des requêtes et des tâches qui joignent et interrogent des tables sur plusieurs comptes. Sous réserve de certaines restrictions, lorsque vous partagez une ressource de catalogue de données avec un autre compte, les principaux associés de ce compte peuvent utiliser cette ressource comme si elle figurait dans leur catalogue de données.
Vous ne partagez pas de ressources avec des responsables spécifiques dans des AWS comptes externes ; vous partagez les ressources avec un compte ou une AWS organisation. Lorsque vous partagez une ressource avec une AWS organisation, vous la partagez avec tous les comptes à tous les niveaux de cette organisation. L'administrateur du lac de données de chaque compte externe doit ensuite accorder des autorisations sur les ressources partagées aux principaux de son compte.
Pour plus d’informations, consultez [Partage de données entre comptes dans Lake Formation](cross-account-permissions.md) et [Octroi d'autorisations sur les ressources du catalogue de données](granting-catalog-permissions.md).
**Voir aussi :**
[Accès aux tables et aux bases de données partagées du catalogue de données et affichage](viewing-shared-resources.md)
[Conditions préalables](cross-account-prereqs.md)
# AWS Glue Data Catalog Vues du bâtiment
Dans le AWS Glue Data Catalog, une *vue* est une table virtuelle dont le contenu est défini par une requête SQL qui fait référence à une ou plusieurs tables. Vous pouvez créer une vue du catalogue de données qui référence jusqu'à 10 tables à l'aide d'éditeurs SQL pour Amazon Athena, Amazon Redshift ou Apache Spark à l'aide d'EMR Serverless ou de la version 5.0. AWS Glue Les tables de référence sous-jacentes d'une vue peuvent appartenir à la même base de données ou à différentes bases Compte AWS de données du même catalogue de données.
Vous pouvez référencer AWS Glue des tables standard et des tables dans des formats de table ouverts (OTF) tels que [Apache Hudi](https://hudi.incubator.apache.org/), Linux Foundation [Delta Lake](https://delta.io/) et [Apache Iceberg](https://iceberg.apache.org/), avec des données sous-jacentes stockées dans des emplacements Amazon S3 enregistrés auprès de. AWS Lake Formation En outre, vous pouvez créer des vues à partir de tables fédérées à partir de partages de données Amazon Redshift partagés avec Lake Formation.
## Différencier les vues du catalogue de données des autres types de vues
Les vues du catalogue de données sont différentes des vues Apache Hive, Apache Spark et Amazon Athena. La vue du catalogue de données est une fonctionnalité native du AWS Glue Data Catalog. Il s'agit d'une vue créée par un définisseur multidialecte. Vous pouvez créer une vue de catalogue de données à l'aide de l'un des services d'analyse pris en charge, tels qu'Athena ou Amazon Redshift Spectrum, et accéder à la même vue à l'aide d'autres services d'analyse pris en charge. D'autre part, les vues Apache Hive, Apache Spark et Athena sont créées indépendamment dans chaque service d'analyse, tel qu'Athena et Amazon Redshift, et sont visibles et accessibles uniquement au sein de ce service.
## Qu'est-ce qu'une vue définissante ?
Une vue de définition est une vue SQL qui fonctionne en fonction des autorisations du principal qui l'a créée. Le rôle de définition dispose des autorisations nécessaires pour accéder aux tables référencées, et il exécute l'instruction SQL qui définit la vue. Le définisseur crée la vue et la partage avec les autres utilisateurs grâce à un AWS Lake Formation contrôle d'accès précis.
Lorsqu'un utilisateur interroge la vue du définisseur, le moteur de requête utilise les autorisations du rôle du définisseur pour accéder aux tables de référence sous-jacentes. Cette approche permet aux utilisateurs d'interagir avec la vue sans avoir besoin d'accéder directement aux tables sources, ce qui améliore la sécurité et simplifie la gestion de l'accès aux données.
Pour configurer une vue de définition, le rôle IAM de définition peut se trouver dans le même AWS compte que les tables de base, ou dans un autre compte en utilisant des rôles de définition entre comptes. Pour plus d'informations sur les autorisations requises pour le rôle de définisseur, consultez[Conditions préalables à la création de vues](views-prereqs.md).
## Un cadre pour des vues multidialectes
Le catalogue de données permet de créer des vues à l'aide de plusieurs dialectes SQL (Structured Query Language). Le SQL est un langage utilisé pour stocker et traiter des informations dans une base de données relationnelle et chaque moteur AWS d'analyse utilise sa propre variante de SQL, ou dialecte SQL.
Vous créez une vue du catalogue de données dans un dialecte SQL à l'aide de l'un des moteurs de requêtes d'analyse pris en charge. Vous pouvez ensuite mettre à jour la vue à l'aide de l'`ALTER VIEW`instruction dans un autre dialecte SQL au sein de tout autre moteur d'analyse pris en charge. Cependant, chaque dialecte doit faire référence au même ensemble de tables, de colonnes et de types de données.
Vous pouvez accéder aux multiples dialectes disponibles pour la vue à l'aide de l'`GetTable`API AWS CLI et de la AWS console. Ainsi, la vue du catalogue de données est visible et disponible pour effectuer des requêtes sur les différents moteurs d'analyse pris en charge.
En définissant un schéma de vue commun et un objet de métadonnées que vous pouvez interroger à partir de plusieurs moteurs, les vues du catalogue de données vous permettent d'utiliser des vues uniformes sur l'ensemble de votre lac de données.
Pour plus de détails sur la façon dont le schéma est résolu pour chaque dialecte, consultez le [lien vers la référence de l'API](). Pour plus de détails sur les règles de correspondance pour les différents types, voir le [lien vers la section correspondante dans le document de l'API]().
## Intégration aux autorisations de Lake Formation
Vous pouvez l'utiliser AWS Lake Formation pour centraliser la gestion des autorisations sur les AWS Glue Data Catalog vues pour les utilisateurs. Vous pouvez accorder des autorisations détaillées sur les vues du catalogue de données à l'aide de la méthode des ressources nommées ou des balises LF, et les partager entre les AWS organisations et les unités organisationnelles. Comptes AWS Vous pouvez également partager et accéder aux vues du catalogue de données Régions AWS via des liens vers des ressources. Cela permet aux utilisateurs d'accéder aux données sans dupliquer la source de données et sans partager les tables sous-jacentes.
L'instruction `CREATE VIEW` DDL d'une vue du catalogue de données peut faire référence aux AWS Glue tables standard et aux tables dans des formats de table ouverts (OTF) tels que Hudi, Delta Lake et Iceberg avec des données sous-jacentes stockées dans des emplacements Amazon S3 enregistrés auprès de Lake Formation, ainsi qu'aux tables fédérées du partage de données Amazon Redshift partagées avec Lake Formation. Les tables peuvent être de n'importe quel format de fichier, à condition que le moteur utilisé pour interroger la vue prenne en charge ce format. Vous pouvez également faire référence aux fonctions intégrées du moteur sur lequel il est exécuté, mais d'autres ressources spécifiques au moteur peuvent ne pas être autorisées. Pour plus d'informations, consultez [Considérations et limites relatives aux affichages du catalogue de données](views-notes.md).
## Cas d’utilisation
Voici les principaux cas d'utilisation des vues du catalogue de données :
+ Créez et gérez les autorisations sur un schéma de vue unique. Cela vous permet d'éviter le risque d'autorisations incohérentes sur les vues dupliquées créées dans plusieurs moteurs.
+ Accordez des autorisations aux utilisateurs sur une vue qui référence plusieurs tables sans accorder d'autorisations directement sur les tables de référence sous-jacentes.
+ Réalisez un filtrage au niveau des lignes sur les tables à l'aide de balises LF (les balises LF ne sont mises en cascade que jusqu'au niveau des colonnes) en appliquant des balises LF aux vues et en accordant aux utilisateurs des autorisations basées sur les balises LF.
## Services AWS d'analyse pris en charge pour les vues
Les services AWS d'analyse suivants permettent de créer des vues de catalogue de données :
+ Amazon Redshift
+ Amazon Athena version 3
+ Apache Spark sur EMR sans serveur
+ Apache Spark sur AWS Glue la version 5.0
## Ressources supplémentaires
Vous pouvez en savoir plus sur le catalogue de données dans ce guide, ainsi qu'en utilisant les ressources suivantes :
La vidéo suivante montre comment créer des vues et les interroger depuis Athena et Amazon Redshift.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/rFO2OoxVYxE?si=Z0qsyuvTp2ZJg-PL)
**Topics**
+ [Différencier les vues du catalogue de données des autres types de vues](#diff-views)
+ [Qu'est-ce qu'une vue définissante ?](#definer-view)
+ [Un cadre pour des vues multidialectes](#multi-dialect)
+ [Intégration aux autorisations de Lake Formation](#lf-view-integ)
+ [Cas d’utilisation](#views-use-cases)
+ [Services AWS d'analyse pris en charge pour les vues](#views-supported-engines)
+ [Ressources supplémentaires](#views-addtional-resources)
+ [Conditions préalables à la création de vues](views-prereqs.md)
+ [Création de vues de catalogue de données à l'aide d'instructions DDL](create-views.md)
+ [Création de vues de catalogue de données à l'aide de AWS Glue APIs](views-api-usage.md)
+ [Octroi d'autorisations sur les vues du catalogue de données](grant-perms-views.md)
+ [Vues matérialisées](materialized-views.md)
# Conditions préalables à la création de vues
+ Pour créer des vues dans Data Catalog, vous devez enregistrer les emplacements de données Amazon S3 sous-jacents des tables de référence auprès de Lake Formation. Pour plus de détails sur l'enregistrement des données auprès de Lake Formation, voir[Ajouter un emplacement Amazon S3 à votre lac de données](register-data-lake.md).
+ Seuls les rôles IAM peuvent créer des vues de catalogue de données. Les autres identités IAM ne peuvent pas créer de vues de catalogue de données.
+ Le rôle IAM qui définit la vue doit disposer des autorisations suivantes :
+ `SELECT`Autorisation Lake Formation avec `Grantable` option sur toutes les tables de référence, toutes les colonnes incluses.
+ `CREATE_TABLE`Autorisation Lake Formation sur la base de données cible dans laquelle les vues sont créées.
+ Une politique de confiance pour que la Lake Formation et AWS Glue les services assument ce rôle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
+ Le but : PassRole l'autorisation pour AWS Glue Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerPassRole1",
"Action": [
"iam:PassRole"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
}
}
}
]
}
```
------
+ AWS Glue et autorisations de Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"Glue:GetDatabase",
"Glue:GetDatabases",
"Glue:CreateTable",
"Glue:GetTable",
"Glue:GetTables",
"Glue:BatchGetPartition",
"Glue:GetPartitions",
"Glue:GetPartition",
"Glue:GetTableVersion",
"Glue:GetTableVersions",
"Glue:PassConnection",
"lakeFormation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
------
+ Vous ne pouvez pas créer de vues dans une base de données `Super` dotée d'une `ALL` autorisation accordée au `IAMAllowedPrincipals` groupe. Vous pouvez soit révoquer l'`Super`autorisation accordée au `IAMAllowedPrincipals` groupe sur une base de données, voir[Étape 4 : Basculez vos magasins de données vers le modèle d'autorisations Lake Formation](upgrade-glue-lake-formation.md#upgrade-glue-lake-formation-step4), soit créer une nouvelle base de données en décochant la case **Utiliser uniquement le contrôle d'accès IAM pour les nouvelles tables de cette base** de données sous **Autorisations par défaut pour les tables nouvellement créées**.
# Création de vues de catalogue de données à l'aide d'instructions DDL
Vous pouvez créer des AWS Glue Data Catalog vues à l'aide des éditeurs SQL pour Athena, Amazon Redshift et à l'aide du/. AWS Glue APIs AWS CLI
Pour créer une vue de catalogue de données à l'aide des éditeurs SQL, choisissez Athena ou Redshift Spectrum, puis créez la vue à l'aide d'une instruction DDL (`CREATE VIEW`Data Definition Language). Après avoir créé une vue dans le dialecte du premier moteur, vous pouvez utiliser une instruction `ALTER VIEW` DDL du second moteur pour ajouter les dialectes supplémentaires.
Lors de la définition des vues, il est important de prendre en compte les points suivants :
+ **Définition de vues multidialectes** : lorsque vous définissez une vue comportant plusieurs dialectes, les schémas des différents dialectes doivent correspondre. Chaque dialecte SQL aura une spécification de syntaxe légèrement différente. La syntaxe de requête définissant la vue du catalogue de données doit aboutir à la même liste de colonnes, y compris les types et les noms, dans tous les dialectes. Ces informations sont stockées dans `StorageDescriptor` la vue. Les dialectes doivent également faire référence aux mêmes objets de table sous-jacents du catalogue de données.
Pour ajouter un autre dialecte à une vue à l'aide du DDL, vous pouvez utiliser l'`ALTER VIEW`instruction. Si une `ALTER VIEW` instruction tente de mettre à jour la définition de la vue, par exemple en modifiant le descripteur de stockage ou les tables sous-jacentes de la vue, l'instruction indique par erreur « Incompatibilité entre le descripteur de stockage en entrée et le descripteur de stockage existant ». Vous pouvez utiliser les opérations SQL Cast pour vous assurer que les types de colonnes de vue correspondent.
+ **Mettre à jour une vue** — Pour mettre à jour la vue, vous pouvez utiliser l'`UpdateTable`API. Si vous mettez à jour la vue sans faire correspondre les descripteurs de stockage ou les tables de référence, vous pouvez fournir l'`FORCE`indicateur (voir la documentation SQL du moteur pour la syntaxe). Après une mise à jour forcée, la vue prendra en compte les tables forcée `StorageDescriptor` et de référence. Tout autre `ALTER VIEW` DDL doit correspondre aux valeurs modifiées. Une vue qui a été mise à jour pour contenir des dialectes incompatibles sera considérée comme « obsolète ». L'état de la vue est visible dans la console Lake Formation et à l'aide de l'`GetTable`opération.
+ **Référencer un type de colonne varchar sous forme de chaîne** — Il n'est pas possible de convertir un type de colonne varchar de Redshift Spectrum en chaîne. Si une vue est créée dans Redshift Spectrum avec un type de colonne varchar et qu'un dialecte ultérieur essaie de référencer ce champ sous forme de chaîne, le catalogue de données le traitera comme une chaîne sans avoir besoin de l'indicateur. `FORCE`
+ **Traitement des champs de type complexe** : Amazon Redshift traite tous les types complexes comme des [SUPER types](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html), tandis qu'Athena spécifie le type complexe. Si une vue possède un champ de `SUPER` type et qu'un autre moteur référence cette colonne comme un type complexe particulier, tel que struct (`>`), le catalogue de données suppose que le champ est du type complexe spécifique et l'utilise dans le descripteur de stockage, sans avoir besoin de l'`Force`indicateur.
Pour plus d'informations sur la syntaxe de création et de gestion des vues du catalogue de données, voir :
+ [Utilisation des AWS Glue Data Catalog vues](https://docs.aws.amazon.com/athena/latest/ug/views-glue.html) dans le guide de l'utilisateur d'Amazon Athena.
+ [Syntaxe des requêtes d'affichage du catalogue Glue Data](https://docs.aws.amazon.com/athena/latest/ug/views-glue-ddl.html) dans le guide de l'utilisateur d'Amazon Athena.
+ [Création de vues AWS Glue Data Catalog dans le manuel](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html) du développeur de base de données Amazon Redshift.
Pour plus d’informations sur les commandes SQL associées aux vues du catalogue de données, consultez [CREATE EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_VIEW.html), [ALTER EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_EXTERNAL_VIEW.html) et [DROP EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_EXTERNAL_VIEW.html).
Une fois que vous avez créé une vue du catalogue de données, les détails de la vue sont disponibles dans la console Lake Formation.
1. Choisissez **Views** sous Data Catalog dans la console Lake Formation.
1. La liste des vues disponibles apparaît sur la page des vues.
1. Choisissez une vue dans la liste et la page de détails affiche les attributs de la vue.
![\[La section inférieure contient cinq onglets disposés horizontalement, chaque onglet contenant les informations correspondantes.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/view-definition.png)
Schema
Choisissez une `Column` ligne, puis sélectionnez **Modifier les balises LF pour mettre à jour les valeurs des balises** ou attribuer de nouvelles balises LF.
Définitions SQL
Vous pouvez consulter la liste des définitions SQL disponibles. Sélectionnez **Ajouter une définition SQL**, puis choisissez un moteur de requête pour ajouter une définition SQL. Choisissez un moteur de requête (Athena ou Amazon Redshift) sous `Edit definition` la colonne pour mettre à jour une définition SQL.
Étiquettes LF
Choisissez **Modifier les balises LF** pour modifier les valeurs d'une balise ou attribuer de nouvelles balises. Vous pouvez utiliser les balises LF pour accorder des autorisations sur les vues.
Accès intercomptes
Vous pouvez consulter la Comptes AWS liste des organisations et unités organisationnelles (OUs) qui ont partagé la vue du catalogue de données avec vous.
Tableaux sous-jacents
Les tables sous-jacentes référencées dans la définition SQL utilisée pour créer la vue sont affichées sous cet onglet.
# Création de vues de catalogue de données à l'aide de AWS Glue APIs
Vous pouvez utiliser AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)et [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html) APIs pour créer et mettre à jour des vues dans le catalogue de données. Les `UpdateTable` opérations `CreateTable` et ont une nouvelle `TableInput` structure pour `ViewDefinition``SearchTables`, tandis que les `GetTableVersions` opérations `GetTable``GetTables`,`GetTableVersion`,, fournissent la syntaxe des vues `ViewDefinition` dans leur sortie. En outre, il existe un nouveau `Status` champ dans la sortie de l'`GetTable`API.
Deux nouvelles AWS Glue connexions sont disponibles pour valider le dialecte SQL pour chaque moteur de requête pris en charge, Amazon Athena ainsi que pour Amazon Redshift.
Les `CreateTable` et `UpdateTable` APIs sont asynchrones lorsqu'ils sont utilisés avec des vues. Lorsque ceux-ci APIs sont appelés avec plusieurs dialectes SQL, l'appel est validé par chaque moteur afin de déterminer si le dialecte peut être exécuté sur ce moteur et si le schéma obtenu de la vue de chaque dialecte correspond. Le AWS Glue service utilise ces connexions pour effectuer des appels internes aux moteurs d'analyse. Ces appels simulent ce que fait le moteur pour valider si un DDL `CREATE VIEW` ou `ALTER VIEW` SQL a été exécuté sur le moteur.
Si le code SQL fourni est valide et que les schémas correspondent aux différents dialectes de vue, l' AWS Glue API valide le résultat de manière atomique. Atomicity permet de créer ou de modifier des vues avec plusieurs dialectes sans aucune interruption.
**Topics**
+ [Création de AWS Glue connexions pour valider le statut](views-api-usage-connection.md)
+ [Validation de l'état de génération de vues](views-api-usage-get-table.md)
+ [États et opérations asynchrones](views-api-usage-async-states.md)
+ [Afficher les scénarios d'échec de création lors d'opérations asynchrones](views-api-usage-errors.md)
# Création de AWS Glue connexions pour valider le statut
Pour créer ou mettre à jour une AWS Glue Data Catalog vue à l'aide `UpdateTable` des opérations `CreateTable` or, vous devez créer un nouveau type de AWS Glue connexion à des fins de validation et le fournir au moteur d'analyse pris en charge. Ces connexions sont nécessaires pour utiliser les vues du catalogue de données avec Athena ou Amazon Redshift. Vous pouvez créer ces connexions uniquement à l'aide du AWS CLI AWS SDKs, ou AWS Glue APIs. Vous ne pouvez pas utiliser le AWS Management Console pour créer la AWS Glue connexion.
**Note**
Si le rôle de définition de la vue et le rôle appelant `CreateTable` ou `UpdateTable` sont différents, ils ont tous deux besoin d'une `glue:PassConnection` autorisation dans leur déclaration de politique IAM.
Pour plus d'informations, consultez la documentation relative à la [création d'une connexion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-connection.html) AWS CLI .
**AWS CLI commande pour créer une connexion**
Voici une AWS CLI commande permettant de créer une connexion :
```
aws glue create-connection --region us-east-1
--endpoint-url https://glue.us-east-1.amazonaws.com
--cli-input-json file:///root/path/to/create-connection.json
```
**AWS CLI entrée JSON**
Pour Amazon Redshift :
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_REDSHIFT",
"Name": "views-preview-cluster-connection-2",
"Description": "My first Amazon Redshift validation connection",
"ConnectionProperties": {
"DATABASE": "dev",
"CLUSTER_IDENTIFIER": "glue-data-catalog-views-preview-cluster"
}
}
}
```
Pour Amazon Athena :
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_ATHENA",
"Name": "views-preview-cluster-connection-3",
"Description": "My first Amazon Athena validation connection",
"ConnectionProperties": {
"WORKGROUP_NAME": "workgroup-name"
}
}
}
```
# Validation de l'état de génération de vues
Lorsque vous exécutez les `UpdateTable` opérations `CreateTable` or, le `Status` champ de sortie de l'`GetTable`API affiche les détails de l'état de création de la vue. Pour les `create` demandes pour lesquelles la table n'existe pas déjà, AWS Glue crée une table vide pendant la durée du processus asynchrone. Lorsque vous appelez`GetTable`, vous pouvez transmettre un indicateur booléen facultatif`IncludeStatusDetails`, qui affiche les informations de diagnostic relatives à la demande. En cas d'échec, cet indicateur affiche un message d'erreur avec les statuts individuels de chaque dialecte.
Des erreurs lors des opérations de création, de lecture, de mise à jour et de suppression de vues (CRUD) peuvent survenir soit pendant le traitement dans le service AWS Glue/Lake Formation, soit lors de la validation SQL de la vue dans Amazon Redshift ou Athena. Lorsqu'une erreur se produit lors de la validation dans un moteur, le AWS Glue service fournit le message d'erreur renvoyé par le moteur.
**Champs de statut**
Les champs de statut sont les suivants :
+ Statut : statut générique, indépendant des différents types d'emplois :
+ QUEUED
+ EN\$1COURS
+ SUCCESS
+ ÉCHEC
+ Action : indique quelle action a été appelée sur la table, actuellement uniquement `CREATE` ou quelles `UPDATE` opérations sont disponibles.
Il est important de faire la distinction entre `CREATE` les opérations `UPDATE` et lorsque vous travaillez avec des vues. Le type d'opération détermine la manière dont vous devez interroger les tables.
Une `UPDATE` opération signifie que la table existe déjà dans le catalogue de données. Dans ce cas, vous pouvez continuer à interroger la table créée précédemment sans aucun problème. D'autre part, une `CREATE ` opération indique que la table n'a jamais été créée avec succès auparavant. Si une table est marquée pour`CREATE`, toute tentative d'interrogation échouera car la table n'existe pas encore dans le système. Il est donc essentiel d'identifier le type d'opération (UPDATE ou CREATE) avant de tenter d'interroger une table.
+ RequestedBy — L'ARN de l'utilisateur qui a demandé la modification asynchrone.
+ UpdatedBy — L'ARN de l'utilisateur qui a modifié manuellement pour la dernière fois le processus de modification asynchrone, par exemple en demandant une annulation ou une modification.
+ Erreur — Ce champ n'apparaît que lorsque l'état est **FAILED**. Il s'agit d'un message d'exception au niveau du parent. Il peut y avoir des erreurs différentes pour chaque dialecte.
+ ErrorCode — Le type d'exception.
+ ErrorMessage — une brève description de l'exception.
+ RequestTime — une chaîne de date au format ISO 8601 indiquant l'heure à laquelle la modification a été initiée.
+ UpdateTime — une chaîne de date au format ISO 8601 indiquant l'heure à laquelle l'état a été mis à jour pour la dernière fois.
# États et opérations asynchrones
Lorsque vous exécutez une `glue:CreateTable` demande, la création asynchrone de la vue du catalogue de données commence. Dans les sections suivantes, ce document décrit une AWS Glue vue disponible dans une `glue:GetTable` réponse. `Status` Par souci de concision, cette section omet la réponse complète.
```
{
"Table": {
...
"Status": {
...
"Action": "CREATE",
"State": "QUEUED",
}
}
}
```
Les deux attributs ci-dessus représentent des informations de diagnostic importantes qui indiquent l'état de l'opération asynchrone, ainsi que les actions qui peuvent être effectuées sur cette vue. Vous trouverez ci-dessous les valeurs possibles que ces attributs peuvent prendre.
1. `Status.Action`
1. CREATE
1. UPDATE
1. `Status.State`
1. QUEUED
1. EN\$1COURS
1. SUCCESS
1. ÉCHEC
Il est également important de noter que certaines mises à jour d'une vue du catalogue de données ne nécessitent pas d'opération asynchrone. Par exemple, on peut souhaiter mettre à jour l'`Description`attribut de la table. Comme cela ne nécessite aucune opération asynchrone, les métadonnées de table résultantes n'en comporteront aucune`Status`, et l'attribut le sera. `NULL`
```
{
"Table": {
...,
"Description": "I changed this attribute!"
}
}
```
Ensuite, cette rubrique explique comment les informations d'état ci-dessus peuvent avoir un impact sur les opérations pouvant être effectuées sur une AWS Glue vue.
**colle : CreateTable**
Il n'y a aucun changement pour cette API par rapport au `glue:CreateTable` fonctionnement de n'importe quelle table Glue. `CreateTable`peut être appelé pour n'importe quel nom de table qui n'existe pas déjà.
**colle : UpdateTable**
Cette opération ne peut pas être effectuée sur une AWS Glue vue dont les informations d'état sont les suivantes :
1. Action = CRÉER et état = EN FILE D'ATTENTE
1. Action == CREATE et État == IN\$1PROGRESS
1. Action == CRÉATION et état == ÉCHEC
1. Action == MISE À JOUR et état == EN ATTENTE
1. Action == MISE À JOUR et état == IN\$1PROGRESS
En résumé, vous ne pouvez mettre à jour une vue du catalogue de données que si elle répond aux exigences suivantes.
1. Il a été créé avec succès pour la première fois.
1. Action == CRÉATION et état == SUCCÈS
1. Il a atteint l'état terminal après une opération de mise à jour asynchrone.
1. Action == MISE À JOUR et état == SUCCÈS
1. Action == MISE À JOUR et état == ÉCHEC
1. Il possède un attribut d'`NULL`état à la suite d'une mise à jour synchrone.
**colle : DeleteTable**
Aucune modification n'est apportée à cette opération par rapport au `glue:DeleteTable` fonctionnement de n'importe quelle AWS Glue table. Vous pouvez supprimer une vue du catalogue de données quel que soit son état.
**colle : GetTable**
Aucune modification n'est apportée à cette opération par rapport au `glue:GetTable` fonctionnement de n'importe quelle AWS Glue table. Toutefois, vous ne pouvez pas interroger une vue du catalogue de données à partir des moteurs d'analyse tant qu'elle n'a pas été créée avec succès pour la première fois. `Action == CREATE and State == SUCCESS`. Après avoir créé une vue du catalogue de données avec succès pour la première fois, vous pouvez interroger la vue quel que soit son statut.
**Note**
Toutes les informations de cette section s'appliquent à tous les tableaux lus`GetTable`, APIs tels que`GetTables`, et`SearchTables`.
# Afficher les scénarios d'échec de création lors d'opérations asynchrones
Les exemples suivants sont représentatifs des types d'erreurs susceptibles de résulter d'appels d'API `CreateTable` ou de leur `UpdateTable` affichage. Ils ne sont pas exhaustifs car la surface d'erreur associée aux échecs de requêtes SQL est assez importante.
## Scénario 1 : échec de la requête Amazon Redshift
La requête fournie pour Amazon Redshift inclut un nom de table mal orthographié introuvable dans le catalogue de données lors de la validation. L'erreur qui en résulte est affichée dans le `Status` champ de la `GetTable` réponse à la vue.
`GetTable`demande :
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-72",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`réponse :
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"UpdateTime": "2024-07-11T11:39:37-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu
Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
}
}
]
}
}
}
}
```
## Scénario 2 : connexion Amazon Redshift non valide
Dans l'exemple suivant, la connexion Amazon Redshift est mal formée car elle fait référence à une base de données Amazon Redshift qui n'existe pas dans le point de terminaison fourni. cluster/serverless Amazon Redshift n'est pas en mesure de valider la vue et le `Status` champ de la `GetTable` réponse indique l'erreur (`"State": "FAILED"`provenant d'Amazon Redshift).
`GetTable`demande :
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-73",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection-malformed"
}
]
}
}
}
```
`GetTable`réponse :
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Timestamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:43:38-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Time
stamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
}
}
]
}
}
}
}
```
## Scénario 3 : échec de la requête Athena
Le code SQL pour Athena ici n'est pas valide car la requête a mal orthographié le nom de la base de données. La validation de la requête Athena détecte cela et l'erreur qui en résulte est détectée dans l'`Status`objet lors d'un appel. `GetTable`
`GetTable`demande :
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-70",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`réponse :
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu Jul 11 18:10:
41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu J
ul 11 18:10:41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "SUCCESS"
}
]
}
}
}
}
```
## Scénario 4 : les descripteurs de stockage ne correspondent pas
Le code SQL fourni pour le dialecte Athena sélectionne `col1` et `col2` tandis que le SQL pour Redshift sélectionne uniquement. `col1` Cela entraîne une erreur de non-concordance du descripteur de stockage.
`GetTable`demande :
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-71",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`réponse :
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:22:49-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
}
]
}
}
}
}
```
# Octroi d'autorisations sur les vues du catalogue de données
Après avoir créé des vues dans le AWS Glue Data Catalog, vous pouvez accorder des autorisations de lac de données sur Comptes AWS les vues aux responsables des organisations et des unités organisationnelles. Vous pouvez accorder des autorisations à l'aide de balises LF ou de la méthode de ressource nommée. Pour plus d'informations sur le balisage des ressources, consultez[Contrôle d'accès basé sur des balises Lake Formation](tag-based-access-control.md). Pour plus d'informations sur l'octroi direct d'autorisations sur les vues, consultez[Octroi d'autorisations sur les vues à l'aide de la méthode de ressource nommée](granting-view-permissions.md).
# Vues matérialisées
**Topics**
+ [Différenciation des vues matérialisées des autres types de vues](#materialized-views-differentiating)
+ [Cas d’utilisation](#materialized-views-use-cases)
+ [Concepts clés](#materialized-views-key-concepts)
+ [Autorisations pour les vues matérialisées](#materialized-views-permissions)
+ [Création et gestion de vues matérialisées](#materialized-views-creating-managing)
+ [Stockage et accès aux données](#materialized-views-storage-access)
+ [Intégration avec AWS Lake Formation les autorisations](#materialized-views-lake-formation)
+ [Surveillance et débogage](#materialized-views-monitoring-debugging)
+ [Gestion des tâches d'actualisation](#materialized-views-managing-refresh-jobs)
+ [Surveillance et résolution des problèmes](#materialized-views-monitoring-troubleshooting)
+ [Considérations et restrictions](#materialized-views-considerations-limitations)
Dans le catalogue de AWS Glue données, une vue matérialisée est une table gérée qui stocke le résultat précalculé d'une requête SQL au format Apache Iceberg. Contrairement aux vues standard du catalogue de données qui exécutent la requête à chaque accès, les vues matérialisées stockent physiquement les résultats de la requête et les mettent à jour à mesure que les tables sources sous-jacentes changent. Vous pouvez créer des vues matérialisées à l'aide d'Apache Spark version 3.5.6\$1 dans Amazon Athena, Amazon EMR ou. AWS Glue
Les vues matérialisées font référence aux tables Apache Iceberg enregistrées dans le catalogue de AWS Glue données, les données précalculées étant stockées sous forme de tables Apache Iceberg dans des compartiments Amazon S3 Tables ou des compartiments à usage général Amazon S3, ce qui les rend accessibles depuis plusieurs moteurs de requêtes, notamment Amazon Athena, Amazon Redshift et des moteurs tiers compatibles avec Iceberg.
## Différenciation des vues matérialisées des autres types de vues
Les vues matérialisées diffèrent fondamentalement AWS Glue des vues du catalogue de données, des vues Apache Spark et des vues Amazon Athena. Alors que les vues du catalogue de données sont des tables virtuelles qui exécutent la définition de la requête SQL à chaque accès, les vues matérialisées stockent physiquement les résultats des requêtes précalculés. Cela élimine les calculs redondants et améliore considérablement les performances des requêtes pour les transformations complexes fréquemment utilisées.
Les vues matérialisées diffèrent également des pipelines de transformation de données traditionnels créés avec des tâches AWS Glue ETL ou Spark personnalisées. Au lieu d'écrire du code personnalisé pour gérer la détection des modifications, les mises à jour incrémentielles et l'orchestration du flux de travail, vous définissez des vues matérialisées à l'aide de la syntaxe SQL standard. Le catalogue de AWS Glue données surveille automatiquement les tables sources, détecte les modifications et actualise les vues matérialisées à l'aide d'une infrastructure informatique entièrement gérée.
## Cas d’utilisation
Les principaux cas d'utilisation des vues matérialisées sont les suivants :
+ **Accélérez les requêtes analytiques complexes** : créez des vues matérialisées qui précalculent les jointures, les agrégations et les fonctions de fenêtre coûteuses. Les moteurs Spark réécrivent automatiquement les requêtes suivantes pour utiliser les résultats précalculés, réduisant ainsi la latence des requêtes et les coûts de calcul.
+ **Simplifiez les pipelines de transformation des données** : remplacez les tâches ETL complexes qui gèrent la détection des modifications, les mises à jour incrémentielles et l'orchestration du flux de travail par de simples définitions de vues matérialisées basées sur SQL. Le catalogue AWS Glue de données gère automatiquement toute la complexité opérationnelle.
+ **Activez l'analyse en libre-service avec un accès régi aux données** : créez des vues matérialisées sélectionnées qui transforment les données brutes en ensembles de données prêts à être utilisés par l'entreprise. Accordez aux utilisateurs l'accès à des vues matérialisées sans exposer les tables sources sous-jacentes, ce qui simplifie la gestion de la sécurité tout en renforçant les analyses en libre-service.
+ **Optimisez l'ingénierie des fonctionnalités pour l'apprentissage automatique** : définissez des vues matérialisées qui implémentent des transformations de fonctionnalités pour les modèles ML. La fonctionnalité d'actualisation automatique garantit que les magasins de fonctionnalités restent à jour au fur et à mesure de l'évolution des données sources, tandis que l'actualisation incrémentielle minimise les coûts de calcul.
+ **Mettez en œuvre un partage de données efficace** : créez des vues matérialisées qui filtrent et transforment les données pour des consommateurs spécifiques. Partagez des vues matérialisées entre les comptes et les régions en AWS Lake Formationéliminant le besoin de duplication des données tout en maintenant une gouvernance centralisée.
## Concepts clés
### Actualisation automatique
L'actualisation automatique est une fonctionnalité qui surveille en permanence vos tables sources et met à jour les vues matérialisées selon un calendrier que vous définissez. Lorsque vous créez une vue matérialisée, vous pouvez spécifier une fréquence d'actualisation à l'aide d'une planification basée sur le temps avec des intervalles allant jusqu'à une heure. Le catalogue de AWS Glue données utilise l'infrastructure informatique gérée de Spark pour exécuter les opérations d'actualisation en arrière-plan, en gérant de manière transparente tous les aspects de la détection des modifications et des mises à jour incrémentielles.
Lorsque les données source changent entre les intervalles d'actualisation, la vue matérialisée devient temporairement obsolète. Les requêtes accédant directement à la vue matérialisée peuvent renvoyer des résultats obsolètes jusqu'à la fin de la prochaine actualisation planifiée. Pour les scénarios nécessitant un accès immédiat aux données les plus récentes, vous pouvez exécuter une actualisation manuelle à l'aide de la commande `REFRESH MATERIALIZED VIEW` SQL.
### Actualisation incrémentielle
L'actualisation incrémentielle est une technique d'optimisation qui traite uniquement les données modifiées dans les tables sources depuis la dernière actualisation, plutôt que de recalculer l'intégralité de la vue matérialisée. Le catalogue de AWS Glue données utilise la couche de métadonnées d'Apache Iceberg pour suivre efficacement les modifications apportées aux tables sources et déterminer quelles parties de la vue matérialisée nécessitent des mises à jour.
Cette approche réduit considérablement les coûts de calcul et la durée d'actualisation par rapport aux opérations d'actualisation complètes, en particulier pour les grands ensembles de données où seul un faible pourcentage des données change entre les cycles d'actualisation. Le mécanisme d'actualisation incrémentielle fonctionne automatiquement ; il n'est pas nécessaire d'écrire une logique personnalisée pour détecter ou traiter les données modifiées.
### Réécriture automatique des requêtes
La réécriture automatique des requêtes est une fonctionnalité d'optimisation des requêtes disponible dans les moteurs Spark d'Amazon Athena, Amazon EMR et. AWS Glue Lorsque vous exécutez une requête sur des tables de base, l'optimiseur Spark analyse votre plan de requête et détermine automatiquement si les vues matérialisées disponibles peuvent répondre plus efficacement à la requête. S'il existe une vue matérialisée appropriée, l'optimiseur réécrit la requête de manière transparente afin d'utiliser les résultats précalculés au lieu de traiter les tables de base.
Cette optimisation s'effectue sans qu'il soit nécessaire de modifier le code de votre application ou les instructions de requête. L'optimiseur Spark garantit que la réécriture automatique des requêtes ne s'applique que lorsque la vue matérialisée est actuelle et peut produire des résultats précis. Si une vue matérialisée est obsolète ou ne répond pas entièrement aux exigences de la requête, l'optimiseur exécute le plan de requête d'origine par rapport aux tables de base, en privilégiant l'exactitude par rapport aux performances.
### Afficher le rôle du définisseur
Une vue matérialisée fonctionne en fonction des autorisations du rôle IAM qui l'a créée, connu sous le nom de rôle de définition de vue. Le rôle de définisseur doit avoir un accès en lecture à toutes les tables de base référencées dans la définition de la vue matérialisée et créer des autorisations de table sur la base de données cible. Lorsque le catalogue de AWS Glue données actualise une vue matérialisée, il assume le rôle de définisseur pour accéder aux tables sources et écrire les résultats mis à jour.
Ce modèle de sécurité vous permet d'accorder aux utilisateurs l'accès aux vues matérialisées sans leur accorder d'autorisations directes sur les tables sources sous-jacentes. Si le rôle de définition de vues perd l'accès à une table de base, les opérations d'actualisation suivantes échoueront jusqu'à ce que les autorisations soient restaurées.
## Autorisations pour les vues matérialisées
Pour créer et gérer des vues matérialisées, vous devez configurer AWS Lake Formation les autorisations. Le rôle IAM qui crée la vue matérialisée (le rôle de définition) nécessite des autorisations spécifiques sur les tables sources et les bases de données cibles.
### Autorisations requises pour le rôle de définisseur
Le rôle de définition doit disposer des autorisations Lake Formation suivantes :
+ Sur les tables sources : autorisations SELECT ou ALL sans filtres de ligne, de colonne ou de cellule
+ Sur la base de données cible : autorisation CREATE\$1TABLE
+ Sur le catalogue AWS Glue de données GetTable et les autorisations CreateTable d'API
Lorsque vous créez une vue matérialisée, l'ARN du rôle de définition est stocké dans la définition de la vue. Le catalogue AWS Glue de données assume ce rôle lors de l'exécution des opérations d'actualisation automatique. Si le rôle de définition perd l'accès aux tables sources, les opérations d'actualisation échoueront tant que les autorisations ne seront pas restaurées.
### Autorisations IAM pour les tâches AWS Glue
Le rôle IAM de votre AWS Glue travail nécessite les autorisations suivantes :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetCatalogs",
"glue:GetTable",
"glue:GetTables",
"glue:CreateTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetDatabase",
"glue:GetDatabases",
"cloudwatch:PutMetricData"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:*:/aws-glue/*"
]
},
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
Le rôle que vous utilisez pour l'actualisation automatique de Materialized View doit disposer de l'PassRole autorisation iam : sur le rôle.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Pour que Glue actualise automatiquement la vue matérialisée pour vous, le rôle doit également respecter la politique de confiance suivante qui permet au service d'assumer le rôle.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Si la vue matérialisée est stockée dans des compartiments de tables S3, vous devez également ajouter l'autorisation suivante au rôle.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3tables:PutTableMaintenanceConfiguration"
],
"Resource": "arn:aws:s3tables:*:123456789012:*"
}
]
}
```
### Octroi de l'accès aux vues matérialisées
Pour autoriser d'autres utilisateurs à interroger une vue matérialisée, accordez l' AWS Lake Formation autorisation SELECT sur la table des vues matérialisées. Les utilisateurs peuvent interroger la vue matérialisée sans avoir besoin d'accéder directement aux tables sources sous-jacentes.
Pour des informations détaillées sur la configuration des autorisations de Lake Formation, consultez la section Octroi et révocation d'autorisations sur les ressources du catalogue de données dans le manuel du AWS Lake Formation développeur.
## Création et gestion de vues matérialisées
Vous créez des vues matérialisées à l'aide de l'`CREATE MATERIALIZED VIEW`instruction SQL dans les moteurs Spark. La définition de la vue spécifie la requête SQL qui définit la logique de transformation, la base de données cible et le nom de la table, ainsi que la configuration d'actualisation facultative. Vous pouvez définir des transformations complexes, notamment des agrégations, des jointures entre plusieurs tables, des filtres et des fonctions de fenêtre.
```
CREATE MATERIALIZED VIEW sales_summary
AS
SELECT
region,
product_category,
SUM(sales_amount) as total_sales,
COUNT(DISTINCT customer_id) as unique_customers
FROM sales_transactions
WHERE transaction_date >= current_date - interval '90' day
GROUP BY region, product_category;
```
Pour configurer l'actualisation automatique, incluez le calendrier d'actualisation dans la définition de votre vue :
```
CREATE MATERIALIZED VIEW sales_summary
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT region, product_category, SUM(sales_amount) as total_sales
FROM sales_transactions
GROUP BY region, product_category;
```
Vous pouvez actualiser manuellement une vue matérialisée à tout moment à l'aide de la `REFRESH MATERIALIZED VIEW` commande :
```
REFRESH MATERIALIZED VIEW sales_summary;
```
Pour modifier le calendrier d'actualisation d'une vue matérialisée existante, utilisez l'`ALTER MATERIALIZED VIEW`instruction suivante :
```
ALTER MATERIALIZED VIEW sales_summary
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```
### Vues matérialisées imbriquées
Vous pouvez créer des vues matérialisées qui font référence à d'autres vues matérialisées sous forme de tables de base, ce qui permet des transformations de données en plusieurs étapes. Lorsque vous créez des vues matérialisées imbriquées, le catalogue de AWS Glue données suit les dépendances et propage automatiquement les mises à jour dans la hiérarchie des vues matérialisées. Lorsqu'une vue matérialisée de base est actualisée, toutes les vues matérialisées en aval qui en dépendent sont mises à jour en conséquence.
Cette fonctionnalité vous permet de décomposer les transformations complexes en étapes logiques, d'améliorer la maintenabilité et de permettre l'actualisation sélective des couches de transformation en fonction de vos exigences en matière de fraîcheur des données.
## Stockage et accès aux données
Les vues matérialisées stockent les résultats précalculés sous forme de tables Apache Iceberg dans des compartiments S3 Tables ou de compartiments S3 à usage général au sein de votre compte. AWS Le catalogue de AWS Glue données gère tous les aspects de la maintenance des tables Iceberg, y compris le compactage et la conservation des instantanés, grâce aux fonctionnalités d'optimisation automatisées de S3 Tables.
Les vues matérialisées étant stockées sous forme de tables Iceberg, vous pouvez les lire directement à partir de n'importe quel moteur compatible avec Iceberg, notamment Amazon Athena, Amazon Redshift et des plateformes d'analyse tierces. Cette accessibilité multimoteur garantit que vos données précalculées restent accessibles dans l'ensemble de votre écosystème d'analyse sans duplication des données ni conversion de format.
## Intégration avec AWS Lake Formation les autorisations
Vous pouvez l'utiliser AWS Lake Formation pour gérer des autorisations précises sur les vues matérialisées. Le créateur de la vue devient automatiquement propriétaire de la vue matérialisée et peut accorder des autorisations à d'autres utilisateurs ou rôles à l'aide AWS Lake Formation de sa méthode de ressource nommée ou de balises LF.
Lorsque vous accordez à un utilisateur l'`SELECT`autorisation d'accéder à une vue matérialisée, il peut interroger les résultats précalculés sans avoir besoin d'accéder aux tables sources sous-jacentes. Ce modèle de sécurité simplifie la gestion de l'accès aux données et vous permet de mettre en œuvre le principe du moindre privilège, en permettant aux utilisateurs d'accéder uniquement aux transformations de données spécifiques dont ils ont besoin.
Vous pouvez partager des vues matérialisées entre AWS comptes, AWS organisations et unités organisationnelles à l'aide des fonctionnalités AWS Lake Formation de partage entre comptes. Vous pouvez également accéder à des vues matérialisées dans toutes AWS les régions à l'aide de liens vers des ressources, ce qui permet une gouvernance centralisée des données avec un accès distribué aux données.
## Surveillance et débogage
Le catalogue de AWS Glue données publie toutes les opérations d'actualisation des vues matérialisées et les métriques associées sur Amazon CloudWatch. Vous pouvez surveiller l'heure de début, l'heure de fin, la durée, le volume de données traité et l'état de l'actualisation grâce à CloudWatch des métriques. Lorsque les opérations d'actualisation échouent, les messages d'erreur et les informations de diagnostic sont enregistrés dans CloudWatch les journaux.
Vous pouvez configurer des CloudWatch alarmes pour recevoir des notifications lorsque les tâches d'actualisation dépassent la durée prévue ou échouent à plusieurs reprises. Le catalogue de AWS Glue données publie également les événements de modification relatifs aux exécutions d'actualisation réussies ou non, ce qui vous permet d'intégrer les opérations de visualisation matérialisée dans une automatisation plus large des flux de travail.
Pour vérifier l'état actuel d'une vue matérialisée, utilisez la commande `DESCRIBE MATERIALIZED VIEW` SQL, qui renvoie des métadonnées telles que l'état d'obsolescence, l'horodatage de la dernière actualisation et la configuration du calendrier d'actualisation.
## Gestion des tâches d'actualisation
### Lancer une actualisation manuelle
Déclenchez une actualisation immédiate en dehors de l'intervalle planifié.
Autorisation requise : les AWS informations d'identification utilisées pour effectuer l'appel d'API doivent être `glue:GetTable` autorisées à accéder à la vue matérialisée.
Pour le catalogue de tables S3 :
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id :s3tablescatalog/ \
--database-name \
--table-name
```
Pour Root Catalog :
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
### Vérification de l'état d'actualisation
Obtenez le statut d'une tâche d'actualisation spécifique :
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id
```
### Historique d'actualisation des annonces
Affichez toutes les tâches d'actualisation pour obtenir une vue matérialisée :
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name
```
**Note**
`:s3tablescatalog/`À utiliser pour les tables S3 ou `` pour le catalogue racine.
### Arrêt d'une actualisation en cours
Annuler une tâche d'actualisation en cours :
```
aws glue stop-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
## Surveillance et résolution des problèmes
Il existe trois méthodes pour surveiller les tâches d'actualisation des vues matérialisées :
### CloudWatch Métriques
Consultez les statistiques agrégées pour toutes vos tâches d'actualisation de vues matérialisées dans CloudWatch :
Métriques disponibles :
+ AWS/Glue l'espace de noms avec les dimensions suivantes :
+ CatalogId: identifiant de votre catalogue
+ DatabaseName: base de données contenant la vue matérialisée
+ TableName: nom de la vue matérialisée
+ TaskType: défini sur « MaterializedViewRefresh »
Affichage dans la console :
1. Accédez à la CloudWatch console → Métriques
1. Sélectionnez l'espace de AWS noms /Glue
1. Filtrer par dimensions : CatalogId, DatabaseName, TableName, TaskType
1. Afficher les indicateurs de réussite, d'échec et de durée des tâches
Exemple de requête de CloudWatch métriques :
```
{AWS/Glue,CatalogId,DatabaseName,TableName,TaskType} MaterializedViewRefresh
```
En utilisant AWS CLI :
```
aws cloudwatch get-metric-statistics \
--namespace AWS/Glue \
--metric-name \
--dimensions Name=CatalogId,Value= \
Name=DatabaseName,Value= \
Name=TableName,Value= \
Name=TaskType,Value=MaterializedViewRefresh \
--start-time \
--end-time \
--period 3600 \
--statistics Sum \
--region
```
### CloudWatch Journaux
Consultez les journaux d'exécution détaillés pour chaque exécution de tâches d'actualisation :
Groupe de journaux : `/aws-glue/materialized-views/`
Où se `` trouve un UUID (par exemple, abc12345-def6-7890-ghij-klmnopqrstuv).
Affichage des journaux :
```
# List log streams for a task run
aws logs describe-log-streams \
--log-group-name /aws-glue/materialized-views/ \
--region
# Get log events
aws logs get-log-events \
--log-group-name /aws-glue/materialized-views/ \
--log-stream-name \
--region
```
Dans CloudWatch la console :
1. Accédez à CloudWatch → Groupes de journaux
1. Recherchez /aws-glue/materialized-views/
1. Sélectionnez le groupe de journaux avec votre ID d'exécution de tâche
1. Afficher les journaux d'exécution détaillés, les erreurs et les résultats des tâches Spark
### Notifications
Abonnez-vous aux événements pour recevoir des notifications en temps réel concernant les modifications de l'état des tâches d'actualisation :
Types d'événements disponibles :
+ La tâche d'actualisation de Glue Materialized View a démarré
+ La tâche d'actualisation de Glue Materialized View a réussi
+ Echec de la tâche d'actualisation de Glue Materialized View
+ Échec de l'invocation de l'actualisation automatique de Glue Materialized View
Création d'une règle :
```
aws events put-rule \
--name materialized-view-refresh-notifications \
--event-pattern '{
"source": ["aws.glue"],
"detail-type": [
"Glue Materialized View Refresh Task Started",
"Glue Materialized View Refresh Task Succeeded",
"Glue Materialized View Refresh Task Failed",
"Glue Materialized View Auto-Refresh Invocation Failure"
]
}' \
--region
```
Ajouter une cible (par exemple, une rubrique SNS) :
```
aws events put-targets \
--rule materialized-view-refresh-notifications \
--targets "Id"="1","Arn"="arn:aws:sns:::" \
--region
```
### Affichage de l'état d'actualisation
Vérifiez l'état de vos tâches d'actualisation de vues matérialisées à l'aide de l' AWS Glue API :
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id \
--region
```
Ou listez toutes les opérations d'actualisation récentes :
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name \
--region
```
Cela montre :
+ Heure de la dernière actualisation
+ État d'actualisation (RÉUSSI, ÉCHEC, EXÉCUTION, ARRÊT)
+ ID d'exécution de la tâche
+ Messages d'erreur (en cas d'échec)
États d'actualisation courants :
+ EN COURS D'EXÉCUTION : le travail d'actualisation est en cours d'exécution
+ RÉUSSI : L'actualisation s'est terminée avec succès
+ ÉCHEC : une erreur s'est produite lors de l'actualisation
+ ARRÊTÉ : L'actualisation a été annulée manuellement
Résolution des problèmes d'échec des actualisations :
Si l'actualisation échoue, vérifiez :
1. Autorisations IAM : assurez-vous que le rôle de définisseur a accès à toutes les tables de base et à l'emplacement de la vue matérialisée
1. Disponibilité des tables de base : Vérifiez que toutes les tables référencées existent et sont accessibles
1. Validité de la requête : vérifiez que la requête SQL est valide pour le dialecte Spark SQL
1. Limites de ressources : vérifiez si vous avez atteint les limites d'actualisation simultanées de votre compte
Utilisez l' GetMaterializedViewRefreshTaskRun API pour récupérer des messages d'erreur détaillés.
## Considérations et restrictions
+ Les vues matérialisées peuvent uniquement faire référence aux tables Apache Iceberg enregistrées dans le catalogue de AWS Glue données en tant que tables de base.
+ La création de vues et la réécriture automatique des requêtes ne sont disponibles qu'à partir des moteurs Spark dans les versions 3.5.6 et supérieures d'Apache Spark sur Amazon Athena AWS Glue , Amazon EMR et (version 5.1).
+ Les vues matérialisées sont finalement cohérentes avec les tables de base. Au cours de la fenêtre d'actualisation, les requêtes accédant directement à la vue matérialisée peuvent renvoyer des données obsolètes. Pour accéder immédiatement aux données actuelles, effectuez une actualisation manuelle.
+ L'intervalle d'actualisation automatique minimum est d'une heure. Pour les cas d'utilisation nécessitant des mises à jour plus fréquentes, exécutez des actualisations manuelles par programmation à l'aide de la commande. `REFRESH MATERIALIZED VIEW`
+ La réécriture des requêtes privilégie l'exactitude par rapport aux performances. Si une vue matérialisée est obsolète ou ne peut pas répondre avec précision aux exigences de la requête, les moteurs Spark exécutent la requête d'origine sur les tables de base.
# Importation de données à l'aide de flux de travail dans Lake Formation
Avec AWS Lake Formation, vous pouvez importer vos données à l'aide de *flux de travail*. Un flux de travail définit la source de données et le calendrier d'importation des données dans votre lac de données. Il s'agit d'un conteneur pour AWS Glue les robots d'exploration, les tâches et les déclencheurs utilisés pour orchestrer les processus de chargement et de mise à jour du lac de données.
**Topics**
+ [Plans et flux de travail dans Lake Formation](workflows-about.md)
+ [Création d'un flux de travail](workflows-creating.md)
+ [Exécution d'un flux de travail](workflows-running.md)
# Plans et flux de travail dans Lake Formation
Un flux de travail encapsule une activité complexe d'extraction, de transformation et de chargement (ETL) multi-tâches. Les flux de travail génèrent des AWS Glue robots, des tâches et des déclencheurs pour orchestrer le chargement et la mise à jour des données. Lake Formation exécute et suit un flux de travail en tant qu'entité unique. Vous pouvez configurer un flux de travail pour qu'il s'exécute à la demande ou selon un calendrier.
**Note**
Spark Parquet Writer ne prend pas en charge les caractères spéciaux dans les noms de colonnes. Il s'agit d'une limitation technique du rédacteur lui-même, et non d'un problème de configuration.
Les flux de travail que vous créez dans Lake Formation sont visibles dans la AWS Glue console sous la forme d'un graphe acyclique dirigé (DAG). Chaque nœud DAG est une tâche, un robot d'exploration ou un déclencheur. Pour suivre les progrès et résoudre les problèmes, vous pouvez suivre l'état de chaque nœud du flux de travail.
Lorsqu'un flux de travail Lake Formation est terminé, l'utilisateur qui l'a exécuté reçoit l'`SELECT`autorisation Lake Formation sur les tables du catalogue de données créées par le flux de travail.
Vous pouvez également créer des flux de travail dansAWS Glue. Cependant, dans la mesure où Lake Formation vous permet de créer un flux de travail à partir d'un plan, la création de flux de travail est beaucoup plus simple et automatisée dans Lake Formation. Lake Formation fournit les types de plans suivants :
+ **Instantané de base** de données : charge ou recharge les données de toutes les tables dans le lac de données à partir d'une source JDBC. Vous pouvez exclure certaines données de la source selon un modèle d'exclusion.
+ **Base de données incrémentielle** : charge uniquement les nouvelles données dans le lac de données à partir d'une source JDBC, en fonction des signets définis précédemment. Vous spécifiez les tables individuelles à inclure dans la base de données source JDBC. Pour chaque tableau, vous choisissez les colonnes des signets et l'ordre de tri des favoris afin de suivre les données précédemment chargées. La première fois que vous exécutez un plan de base de données incrémentiel sur un ensemble de tables, le flux de travail charge toutes les données des tables et définit des signets pour la prochaine exécution du plan de base de données incrémentiel. Vous pouvez donc utiliser un plan de base de données incrémentiel au lieu du plan de capture de base de données pour charger toutes les données, à condition de spécifier chaque table de la source de données en tant que paramètre.
+ **Fichier journal** : charge en bloc des données à partir de sources de fichiers journaux AWS CloudTrail, notamment les journaux Elastic Load Balancing et les journaux Application Load Balancer.
Utilisez le tableau suivant pour déterminer s'il convient d'utiliser un instantané de base de données ou un plan de base de données incrémentiel.
| Utilisez un instantané de base de données lorsque... | Utiliser une base de données incrémentielle lorsque... |
| --- | --- |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/workflows-about.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/workflows-about.html) |
**Note**
Les utilisateurs ne peuvent pas modifier les plans et les flux de travail créés par Lake Formation.
# Création d'un flux de travail
Avant de commencer, assurez-vous d'avoir accordé au rôle les autorisations de données et les autorisations de localisation des données requises`LakeFormationWorkflowRole`. Le flux de travail peut ainsi créer des tables de métadonnées dans le catalogue de données et écrire des données vers des emplacements cibles dans Amazon S3. Pour plus d’informations, consultez [(Facultatif) Créez un rôle IAM pour les flux de travail](initial-lf-config.md#iam-create-blueprint-role) et [Vue d'ensemble des autorisations relatives à Lake Formation](lf-permissions-overview.md).
**Note**
Lake Formation utilise `GetTemplateInstance``GetTemplateInstances`, et effectue des `InstantiateTemplate` opérations pour créer des flux de travail à partir de plans. Ces opérations ne sont pas accessibles au public et ne sont utilisées qu'en interne pour créer des ressources en votre nom. Vous recevez des CloudTrail événements pour créer des flux de travail.
**Pour créer un flux de travail à partir d'un plan**
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous en tant qu'administrateur du lac de données ou en tant qu'utilisateur disposant d'autorisations d'ingénieur de données. Pour de plus amples informations, veuillez consulter [Référence des personnalités de Lake Formation et des autorisations IAM](permissions-reference.md).
1. Dans le volet de navigation, choisissez **Blueprints**, puis choisissez **Use Blueprint**.
1. Sur la page **Utiliser un plan**, choisissez une vignette pour sélectionner le type de plan.
1. Sous **Source d'importation**, spécifiez la source de données.
Si vous effectuez une importation à partir d'une source JDBC, spécifiez les éléments suivants :
+ ****Connexion à la base**** de données —Choisissez une connexion dans la liste. Créez des connexions supplémentaires à l'aide de la AWS Glue console. Le nom d'utilisateur et le mot de passe JDBC de la connexion déterminent les objets de base de données auxquels le flux de travail a accès.
+ ****Chemin des données source**** : entrez**/**/**ou**/**, selon le produit de base de données. Oracle Database et MySQL ne prennent pas en charge le schéma dans le chemin. Vous pouvez remplacer le pourcentage (%) par ** ou**. Par exemple, pour une base de données Oracle dont l'identifiant système (SID) est égal `orcl/%` à`orcl`, entrez pour importer toutes les tables auxquelles l'utilisateur nommé dans la connexion a accès.
**Important**
Ce champ distingue les majuscules et minuscules. Le flux de travail échouera s'il existe une incompatibilité majuscules/minuscules pour l'un des composants.
Si vous spécifiez une base de données MySQL, AWS Glue ETL utilise le pilote JDBC Mysql5 par défaut, donc My SQL8 n'est pas pris en charge nativement. Vous pouvez modifier le script de tâche ETL pour utiliser un `customJdbcDriverS3Path` paramètre tel que décrit dans la section [JDBC ConnectionType Values](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-jdbc) du *manuel du AWS Glue développeur* afin d'utiliser un autre pilote JDBC compatible avec My. SQL8
Si vous effectuez une importation à partir d'un fichier journal, assurez-vous que le rôle que vous spécifiez pour le flux de travail (le « rôle de flux de travail ») dispose des autorisations IAM requises pour accéder à la source de données. Par exemple, pour importer AWS CloudTrail des journaux, l'utilisateur doit disposer des `cloudtrail:LookupEvents` autorisations `cloudtrail:DescribeTrails` et pour consulter la liste des CloudTrail journaux lors de la création du flux de travail, et le rôle du flux de travail doit disposer d'autorisations sur l' CloudTrail emplacement dans Amazon S3.
1. Effectuez l’une des actions suivantes :
+ Pour le type de plan **instantané de base** de données, identifiez éventuellement un sous-ensemble de données à importer en spécifiant un ou plusieurs modèles d'exclusion. Ces modèles d'exclusion sont des modèles de style Unix. `glob` Ils sont stockés en tant que propriété des tables créées par le flux de travail.
Pour plus de détails sur les modèles d'exclusion disponibles, consultez la section [Include et d'exclusion des modèles](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) dans le *manuel du AWS Glue développeur*.
+ Pour le type de plan **de base de données incrémentiel**, spécifiez les champs suivants. Ajoutez une ligne pour chaque table à importer.
**Nom de la table**
Tableau à importer. Tout doit être en minuscules.
**Clés de signet**
Liste de noms de colonnes séparés par des virgules qui définissent les clés des signets. Si ce champ est vide, la clé primaire est utilisée pour déterminer les nouvelles données. Le cas de chaque colonne doit correspondre au cas défini dans la source de données.
La clé primaire est considérée comme la clé de signet par défaut uniquement si elle augmente ou diminue de manière séquentielle (sans interruption). Si vous souhaitez utiliser la clé primaire comme clé de signet et qu'elle comporte des lacunes, vous devez nommer la colonne de clé primaire comme clé de signet.
**Marquer la commande**
Lorsque vous choisissez **Ascending,** les lignes dont les valeurs sont supérieures aux valeurs enregistrées dans les favoris sont identifiées comme de nouvelles lignes. Lorsque vous choisissez **Décroissant**, les lignes dont les valeurs sont inférieures aux valeurs enregistrées dans les favoris sont identifiées comme de nouvelles lignes.
**Schéma de partitionnement**
(Facultatif) Liste des colonnes clés de partitionnement, délimitées par des barres obliques (/). Exemple :` year/month/day`.
![\[La section des données incrémentielles de la console inclut les champs suivants : nom de la table, clés des signets, ordre des signets, schéma de partitionnement. Vous pouvez ajouter ou supprimer des lignes, chaque ligne correspondant à un tableau différent.\]](http://docs.aws.amazon.com/fr_fr/lake-formation/latest/dg/images/incremental-data.png)
Pour plus d'informations, consultez la section [Suivi des données traitées à l'aide des signets de tâches](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) dans le *Guide du AWS Glue développeur*.
1. Sous **Cible d'importation**, spécifiez la base de données cible, l'emplacement Amazon S3 cible et le format des données.
Assurez-vous que le rôle de flux de travail dispose des autorisations Lake Formation requises sur la base de données et sur l'emplacement cible Amazon S3.
**Note**
À l'heure actuelle, les plans ne prennent pas en charge le chiffrement des données sur la cible.
1. Choisissez une fréquence d'importation.
Vous pouvez spécifier une `cron` expression à l'aide de l'option **Personnalisée**.
1. Sous **Options d'importation** :
1. Entrez un nom de flux de travail.
1. Pour rôle, choisissez le rôle `LakeFormationWorkflowRole` que vous avez créé dans[(Facultatif) Créez un rôle IAM pour les flux de travail](initial-lf-config.md#iam-create-blueprint-role).
1. Spécifiez éventuellement un préfixe de table. Le préfixe est ajouté aux noms des tables du catalogue de données créées par le flux de travail.
1. Choisissez **Créer** et attendez que la console indique que le flux de travail a été créé avec succès.
**Astuce**
Avez-vous reçu le message d'erreur suivant ?
`User: arn:aws:iam:::user/ is not authorized to perform: iam:PassRole on resource:arn:aws:iam:::role/...`
Si tel est le cas, vérifiez que vous l'avez ** remplacé par un numéro de AWS compte valide dans toutes les polices.
**Voir aussi :**
[Plans et flux de travail dans Lake Formation](workflows-about.md)
# Exécution d'un flux de travail
Vous pouvez exécuter un flux de travail à l'aide de la console Lake Formation, de la AWS Glue console, de l'interface de ligne de AWS Glue commande (AWS CLI) ou de l'API.
**Pour exécuter un flux de travail (console Lake Formation)**
1. Ouvrez la AWS Lake Formation console à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Connectez-vous en tant qu'administrateur du lac de données ou en tant qu'utilisateur disposant d'autorisations d'ingénieur de données. Pour de plus amples informations, veuillez consulter [Référence des personnalités de Lake Formation et des autorisations IAM](permissions-reference.md).
1. Dans le panneau de navigation, sélectionnez **Blueprints (Modèles)**.
1. Sur la page **Blueprints**, sélectionnez le flux de travail. Ensuite, dans le menu **Actions**, choisissez **Démarrer**.
1. Au fur et à mesure que le flux de travail s'exécute, consultez sa progression dans la colonne **État de la dernière exécution**. Cliquez sur le bouton d'actualisation de temps en temps.
Le statut passe de « **EN COURS** » à « **Découverte** », puis « **Importation** », puis « **TERMINÉ** ».
Lorsque le flux de travail est terminé :
+ Le catalogue de données contient de nouvelles tables de métadonnées.
+ Vos données sont ingérées dans le lac de données.
Si le flux de travail échoue, procédez comme suit :
1. Sélectionnez un flux de travail. Choisissez **Actions**, puis **Afficher le graphique**.
Le flux de travail s'ouvre dans la AWS Glue console.
1. Assurez-vous que le flux de travail est sélectionné, puis sélectionnez l'onglet **History (Historique)**.
1. Sous **Historique**, sélectionnez l'exécution la plus récente et choisissez **Afficher les détails de la course**.
1. Sélectionnez une tâche ou un robot d'exploration ayant échoué dans le graphique dynamique (d'exécution) et consultez le message d'erreur. Les nœuds défaillants sont rouges ou jaunes.
**Voir aussi :**
[Plans et flux de travail dans Lake Formation](workflows-about.md)