# 填充 AWS Glue Data Catalog
您可以使用以下方法填充 AWS Glue Data Catalog：
+ AWS Glue 爬网程序 – AWS Glue 爬网程序 可以自动发现数据库、数据湖和流式传输数据等数据来源并对其进行分类。爬网程序可以自动发现和推断各种数据来源的元数据，因此是填充 Data Catalog 的最常用和最推荐的方法。
+ 手动添加元数据 – 您可以使用 AWS Glue 控制台、Lake Formation 控制台、AWS CLI 或 AWS Glue API 手动定义数据库、表和连接详细信息，并将其添加到 Data Catalog 中。当您要对无法爬取的数据来源进行分类时，手动输入非常有用。
+ 与其他 AWS 服务集成 – 您可以使用来自 AWS Lake Formation 和 Amazon Athena 等服务的元数据填充 Data Catalog。这些服务可以在 Data Catalog 中发现和注册数据来源。
+ 从现有元数据存储库中填充 – 如果您有 Apache Hive Metastore 这样的现有元数据存储，则可以使用 AWS Glue 将该元数据导入到 Data Catalog 中。有关更多信息，请参阅 GitHub 上的[在 Hive 元存储和 AWS Glue Data Catalog 之间迁移](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Hive_metastore_migration)。
**Topics**
+ [使用爬网程序填充 Data Catalog](add-crawler.md)
+ [手动定义元数据](populate-dg-manual.md)
+ [与 Amazon S3 表类数据存储服务集成](glue-federation-s3tables.md)
+ [与其他 AWS 服务集成](populate-dc-other-services.md)
+ [Data Catalog 设置](console-data-catalog-settings.md)
# 使用爬网程序填充 Data Catalog
您可以使用 AWS Glue 爬网程序，将数据库和表填充到 AWS Glue Data Catalog。这是大多数 AWS Glue 用户使用的主要方法。爬网程序可以在单次运行中爬取多个数据存储。完成后，爬网程序会在数据目录中创建或更新一个或多个表。您在 AWS Glue 中定义的提取、转换和加载（ETL）任务使用这些数据目录表作为源和目标。ETL 任务从在源和目标数据目录表中指定的数据存储中读取内容并向其中写入内容。
## 工作流
以下流程图显示了 AWS Glue 爬网程序如何与数据存储和其他元素交互来填充数据目录。
![\[工作流程显示 AWS Glue 爬网程序用 5 个基本步骤填充数据目录。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/PopulateCatalog-overview.png)
以下是爬网程序如何填充 AWS Glue Data Catalog 的一般工作流程：
1. 爬网程序运行您为推断数据的格式和架构而选择的任何自定义*分类器*。您为自定义分类器提供代码，它们按您指定的顺序运行。
第一个成功识别您的数据结构的自定义分类器用于创建架构。将会跳过列表中较低的自定义分类器。
1. 如果没有自定义分类器与您的数据的架构匹配，则内置分类符会尝试识别数据的架构。内置分类器的示例是一个可识别 JSON 的分类器。
1. 爬网程序连接到数据存储。某些数据存储需要使用连接属性才能访问爬网程序。
1. 将会为您的数据创建推断的架构。
1. 爬网程序向数据目录写入元数据。表定义包含有关您的数据存储中的数据的元数据。该表被写入一个充当数据目录中表的容器的数据库。表的属性包括分类，它是由推断表架构的分类器创建的标签。
**Topics**
+ [工作流](#crawler-workflow)
+ [爬网程序的工作原理](#crawler-running)
+ [爬网程序如何确定何时创建分区？](#crawler-s3-folder-table-partition)
+ [支持的可供爬取的数据来源](crawler-data-stores.md)
+ [爬网程序先决条件](crawler-prereqs.md)
+ [定义和管理分类器](add-classifier.md)
+ [配置爬网程序](define-crawler.md)
+ [计划爬网程序](schedule-crawler.md)
+ [查看爬网程序结果和详细信息](console-crawlers-details.md)
+ [自定义爬网程序行为](crawler-configuration.md)
+ [教程：添加 AWS Glue 爬网程序](tutorial-add-crawler.md)
## 爬网程序的工作原理
爬网程序在运行时，会执行以下操作来询问数据存储：
+ **对数据分类，以确定原始数据的格式、架构和关联属性** – 您可以通过创建自定义分类器来配置分类结果。
+ **将数据分组为表或分区** – 根据爬网程序探试算法对数据分组。
+ **将元数据写入数据目录** – 您可以配置爬网程序如何添加、更新和删除表和分区。
在定义爬网程序时，您可以选择一个或多个分类器来评估用于推断架构的数据的格式。当爬网程序运行时，列表中的第一个分类器可以成功识别您的数据存储，用于为表创建架构。您可以使用内置分类器或定义您自己的分类器。您可以在定义爬网程序之前，在单独的操作中定义您的自定义分类器。AWS Glue 提供内置分类器，用于使用包含 JSON、CSV 和 Apache Avro 的格式从公共文件中推断架构。有关 AWS Glue 中内置分类器的当前列表，请参阅[内置分类器](add-classifier.md#classifier-built-in)。
爬网程序创建的元数据表包含在定义爬网程序时的数据库中。如果爬网程序未指定数据库，则您的表将放置在默认数据库中。此外，每个表都有一个分类列，由第一个成功识别数据存储的分类器填充。
如果已爬取的文件被压缩，则爬网程序必须下载它才能处理它。在爬网程序运行时，它会询问文件以确定其格式和压缩类型，并将这些属性写入数据目录。某些文件格式（例如 Apache Parquet）允许您在写入文件时压缩文件的一部分。对于这些文件，压缩的数据是文件的内部组件，在将表写入数据目录时，AWS Glue 不会填充 `compressionType` 属性。相反，如果*整个文件*通过压缩算法（例如 gzip）来压缩，则在将表写入数据目录时，会填充 `compressionType` 属性。
爬网程序为它创建的表生成名称。存储在 AWS Glue Data Catalog 中的表的名称遵循以下规则：
+ 仅允许使用字母数字字符和下划线 (`_`)。
+ 任何自定义前缀均不能超过 64 个字符。
+ 名称的最大长度不能超过 128 个字符。爬网程序截断生成的名称以适应限制范围。
+ 如果遇到重复的表名，则爬网程序会向名称中添加哈希字符串后缀。
如果您的爬网程序多次运行 (也许是按计划)，它会在您的数据存储中查找新的或已更改的文件或表。爬网程序的输出包括自上次运行以来找到的新表和分区。
## 爬网程序如何确定何时创建分区？
当 AWS Glue 爬网程序扫描 Amazon S3 数据存储并检测到某个存储桶中有多个文件夹时，它会在文件夹结构中确定表的根，以及哪些文件夹是表的分区。表的名称基于 Amazon S3 前缀或文件夹名称。您提供一个**包含路径**，它指向要爬网的文件夹级别。当某个文件夹级别的大部分架构都相似时，爬网程序将创建一个表而不是独立表的分区。要影响爬网程序，以创建单独的表，可在定义爬网程序时将每个表的根文件夹添加为单独的数据存储。
例如，考虑以下 Amazon S3 文件夹结构。
![\[多个级别的矩形表示 Amazon S3 中的文件夹层次结构。顶部矩形标记为“Sales (销售额)”。下面的矩形标记为“year=2019 (年份=2019)”。下面的两个矩形标记为“month=Jan (月份=1 月)”和“month=Feb (月份=2 月)”。每个矩形下面都有两个矩形，标记为“day=1 (天=1)”和“day=2 (天=2)”。所有四个“day (天)”（底部）矩形下面都有两个或四个文件。所有矩形和文件都用线连接。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawlers-s3-folders.png)
四个最低级别文件夹的路径如下：
```
S3://sales/year=2019/month=Jan/day=1
S3://sales/year=2019/month=Jan/day=2
S3://sales/year=2019/month=Feb/day=1
S3://sales/year=2019/month=Feb/day=2
```
假设爬网程序目标设置为 `Sales`，并且 `day=n` 文件夹中的所有文件都具有相同的格式（例如 JSON，未加密），并且具有相同或非常相似的架构。爬网程序将创建一个包含四个分区的表，分区键为 `year`、`month` 和 `day`。
在下一个示例中，考虑以下 Amazon S3 结构：
```
s3://bucket01/folder1/table1/partition1/file.txt
s3://bucket01/folder1/table1/partition2/file.txt
s3://bucket01/folder1/table1/partition3/file.txt
s3://bucket01/folder1/table2/partition4/file.txt
s3://bucket01/folder1/table2/partition5/file.txt
```
如果 `table1` 和 `table2` 下的文件架构相似，并且在爬网程序中通过**包含路径** `s3://bucket01/folder1/` 定义了单个数据存储，爬网程序将创建一个具有两个分区键列的表。第一个分区键列包含 `table1` 和 `table2`，第二个分区键列包含 `table1` 分区的 `partition1` 到 `partition3` 以及 `table2` 分区的 `partition4` 和 `partition5`。要创建两个单独的表，可用两个数据存储来定义爬网程序。在本示例中，将第一个**包含路径**定义为 `s3://bucket01/folder1/table1/`，将第二个定义为 `s3://bucket01/folder1/table2`。
**注意**
在 Amazon Athena 中，每个表对应一个 Amazon S3 前缀，所有对象都在其中。如果对象具有不同架构，Athena 则不会将同一前缀内的不同对象识别为不同的表。如果爬网程序从同一个 Amazon S3 前缀中创建多个表，则可能出现这种情况。这可能会导致 Athena 中的查询返回零个结果。为使 Athena 正确识别和查询表，请在创建爬网程序时，使 Amazon S3 文件夹结构中的每个不同的表架构具有单独的**包含路径**。有关更多信息，请参阅[将 Athena 与 AWS Glue 一起使用时的最佳实践](https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html)以及这篇 [AWS 知识中心文章](https://aws.amazon.com/premiumsupport/knowledge-center/athena-empty-results/)。
# 支持的可供爬取的数据来源
爬网程序可以同时爬取以下基于文件的数据存储和基于表的数据存储。
| 爬网程序使用的访问类型 | 数据存储 |
| --- | --- |
| 本机客户端 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/crawler-data-stores.html) |
| JDBC | Amazon Redshift Snowflake 在 Amazon Relational Database Service（Amazon RDS）内部或 Amazon RDS 外部： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/crawler-data-stores.html) |
| MongoDB 客户端 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/crawler-data-stores.html) |
**注意**
目前，AWS Glue 不支持数据流的爬网程序。
对于 JDBC、MongoDB、MongoDB Atlas 和 Amazon DocumentDB（与 MongoDB 兼容）数据存储，您必须指定爬网程序可用于连接到数据存储的 AWS Glue *连接*。对于 Amazon S3，您可以选择指定网络类型的连接。连接是存储连接信息（例如凭证、URL、Amazon Virtual Private Cloud 信息等）的数据目录对象。有关更多信息，请参阅 [连接到数据](glue-connections.md)。
以下是爬网程序支持的驱动程序版本：
| 产品 | 爬网程序支持的驱动程序 |
| --- | --- |
| PostgreSQL | 42.2.1 |
| Amazon Aurora | 与原生爬网程序爬虫驱动程序相同 |
| MariaDB | 8.0.13 |
| Microsoft SQL Server | 6.1.0 |
| MySQL | 8.0.13 |
| Oracle | 11.2.2 |
| Amazon Redshift | 4.1 |
| Snowflake | 3.13.20 |
| MongoDB | 4.7.2 |
| MongoDB Atlas | 4.7.2 |
以下是有关各种数据存储的说明。
**Amazon S3**
您可以选择在您的账户中或在其他账户中爬取路径。如果文件夹中的所有 Amazon S3 文件具有相同的架构，爬网程序会创建一个表。此外，如果对 Amazon S3 对象进行了分区，则只会创建一个元数据表，并将分区信息添加到该表的数据目录中。
**Amazon S3 和 Amazon DynamoDB**
爬网程序使用 AWS Identity and Access Management（IAM）权限角色来访问您的数据存储。*传递给爬网程序的角色必须有权访问所爬取的 Amazon S3 路径和 Amazon DynamoDB 表*。
**Amazon DynamoDB**
在使用 AWS Glue 控制台定义爬网程序时，请指定一个 DynamoDB 表。如果您使用的是 AWS Glue API，则可以指定表的列表。您可以选择仅爬取一小部分数据样本以减少爬网程序的运行时间。
**Delta Lake**
对于每个 Delta Lake 数据存储，可以指定如何创建 Delta 表：
+ **创建原生表**：允许与支持直接查询 Delta 事务日志的查询引擎集成。有关更多信息，请参阅[查询 Delta Lake 表](https://docs.aws.amazon.com/athena/latest/ug/delta-lake-tables.html)。
+ **创建符号链接表**：根据指定的配置参数，使用由分区键分区的清单文件创建 `_symlink_manifest` 文件夹。
**Iceberg**
对于每个 Iceberg 数据存储，您可以指定一个 Amazon S3 路径，其中包含您的 Iceberg 表的元数据。爬网程序发现 Iceberg 表元数据后，会在 Data Catalog 中注册该元数据。您可以为爬网程序设置计划以保持表格最新。
您可以为数据存储定义以下参数：
+ **排除项**：允许您跳过某些文件夹。
+ **最大遍历深度**：设置爬网程序可以在您的 Amazon S3 存储桶中爬取的深度限制。默认的最大遍历深度为 10；您可以设置的最大深度为 20。
**Hudi**
对于每个 Hudi 数据存储，您可以指定一个 Amazon S3 路径，其中包含您的 Hudi 表的元数据。爬网程序发现 Hudi 表元数据后，会在 Data Catalog 中注册该元数据。您可以为爬网程序设置计划以保持表格最新。
您可以为数据存储定义以下参数：
+ **排除项**：允许您跳过某些文件夹。
+ **最大遍历深度**：设置爬网程序可以在您的 Amazon S3 存储桶中爬取的深度限制。默认的最大遍历深度为 10；您可以设置的最大深度为 20。
由于与 Hudi 0.13.1 和时间戳类型不兼容，逻辑类型为 `millis` 的时间戳列将被解释为 `bigint`。在即将发布的 Hudi 版本中可能会提供解决方案。
Hudi 表分为以下几类，每个表都有具体含义：
+ 写入时复制（CoW）：数据以列式（Parquet）存储，并且每次更新都会在写入过程中创建一个新版本的文件。
+ 读取时合并（MOR）：数据使用列式（Parquet）和基于行（Avro）的格式的组合进行存储。更新记录到基于行的增量文件中，并根据需要进行压缩以创建新版本的列式文件。
对于 CoW 数据集，每次更新记录时，包含该记录的文件都会使用更新后的值进行重写。对于 MoR 数据集，每次进行更新时，Hudi 仅写入已更改记录对应的行。MoR 更适合写入或更改繁重而读取量较少的工作负载。CoW 更适合更改频率较低但读取量繁重的工作负载。
Hudi 提供三个查询类型用于访问数据：
+ 快照查询：该查询用于查看截至给定提交或压缩操作时表的最新快照。对于 MOR 表，快照查询通过在查询时合并最新文件切片的基本文件和增量文件来显示表的最新状态。
+ 增量查询：查询只能看到自给定提交/压缩以来，写入表的新数据。这有效地提供了更改流以启用增量数据管道。
+ 读取优化查询：对于 MoR 表，查询将看到最新压缩的数据。对于 CoW 表，查询将看到最新提交的数据。
对于写入时复制表，爬网程序使用 ReadOptimized serde 在 Data Catalog 中创建单个表。`org.apache.hudi.hadoop.HoodieParquetInputFormat`
对于读取时合并表，爬网程序在 Data Catalog 中为同一个表位置创建两个表：
+ 带有后缀 `_ro` 的表，使用 ReadOptimized serde `org.apache.hudi.hadoop.HoodieParquetInputFormat`。
+ 带有后缀 `_rt` 的表，使用允许快照查询的 RealTime Serde：`org.apache.hudi.hadoop.realtime.HoodieParquetRealtimeInputFormat`。
**MongoDB 和 Amazon DocumentDB (with MongoDB compatibility)**
支持 MongoDB 版本 3.2 及更高版本。您可以选择仅爬取一小部分数据样本以减少爬网程序的运行时间。
**关系数据库**
使用数据库用户名和密码进行身份验证。根据数据库引擎的类型，您可以选择要爬网哪些对象，如数据库、架构和表。
**Snowflake**
Snowflake JDBC 爬网程序支持爬取表、外部表、视图和实体化视图。不会填充实体化视图定义。
对于 Snowflake 外部表，仅爬网程序指向 Amazon S3 位置时才会爬取。除了表架构外，爬网程序还将爬取 Amazon S3的位置、文件格式和输出作为数据目录表中的表参数。请注意，未填充分区外部表的分区信息。
使用 Snowflake 爬网程序创建的数据目录表目前不支持 ETL。
# 爬网程序先决条件
爬网程序代入您在定义它时指定的 AWS Identity and Access Management（IAM）角色的权限。此 IAM 角色必须有权从您的数据存储中提取数据并将其写入数据目录。AWS Glue 控制台仅列出已为 AWS Glue 委托人服务附加信任策略的 IAM 角色。从控制台中，您还可以创建具有 IAM policy 的 IAM 角色，该策略允许访问爬网程序所访问的 Amazon S3 数据存储。有关为 AWS Glue 提供角色的更多信息，请参阅[适用于 AWS Glue 的基于身份的策略](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies)。
**注意**
在爬取 Delta Lake 数据存储时，您必须拥有该 Amazon S3 位置的读/写权限。
对于您的爬网程序，您可以创建一个角色并附加以下策略：
+ `AWSGlueServiceRole` AWS 托管策略，授予对数据目录所需的权限
+ 授予数据源权限的内联策略。
+ 对角色授予 `iam:PassRole` 权限的内联策略。
一种更快的方法是让 AWS Glue 控制台爬网程序向导为您创建一个角色。它创建的角色专用于爬网程序，包括 `AWSGlueServiceRole` AWS 托管策略以及指定数据源所需的内联策略。
如果您为爬网程序指定现有角色，请确保它包含 `AWSGlueServiceRole` 策略或等效策略（或此策略的范围缩小版本），以及所需的内联策略。例如，对于 Amazon S3 数据存储，内联策略至少为以下内容：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::bucket/object*"
]
}
]
}
```
------
对于 Amazon DynamoDB 数据存储，策略至少为以下内容：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeTable",
"dynamodb:Scan"
],
"Resource": [
"arn:aws:dynamodb:us-east-1:111122223333:table/table-name*"
]
}
]
}
```
------
此外，如果爬网程序读取 AWS Key Management Service（AWS KMS）加密的 Amazon S3 数据，则 IAM 角色必须具有 AWS KMS 密钥的解密权限。有关更多信息，请参阅 [步骤 2：为 AWS Glue 创建 IAM 角色](create-an-iam-role.md)。
# 定义和管理分类器
分类器读取数据存储中的数据。如果它可识别数据的格式，它会生成一个架构。分类器还会返回确定性数字，以指示格式识别的确定程度。
AWS Glue 提供一组内置分类器，但您也可以创建自定义分类符。AWS Glue 首先按照您在爬网程序定义中指定的顺序调用自定义分类符。根据从自定义分类符返回的结果，AWS Glue 还可能调用内置分类符。如果分类器在处理期间返回 `certainty=1.0`，则表明 100% 确定它可以创建正确的架构。然后，AWS Glue 使用该分类器的输出。
如果没有分类器返回 `certainty=1.0`，则 AWS Glue 使用具有最高确定性的分类器的输出。如果没有分类器返回大于 `0.0` 的确定性，AWS Glue 会返回 `UNKNOWN` 的默认分类字符串。
## 何时使用分类器？
在网络爬取数据存储以定义 AWS Glue Data Catalog 中的元数据表时，您可以使用分类器。您可以为您的爬网程序设置一组有序的分类器。当爬网程序调用分类器时，分类器会确定数据是否可被识别。如果分类器无法识别数据或不是 100% 确定，则爬网程序会调用列表中的下一个分类器来确定它能否识别数据。
有关使用 AWS Glue 控制台创建分类器的更多信息，请参阅[使用 AWS Glue 控制台创建分类器](console-classifiers.md)。
## 自定义分类器
分类器的输出包含一个指示文件的分类或格式 (例如 `json`) 以及文件的架构的字符串。对于自定义分类器，您根据分类器类型定义用于创建架构的逻辑。分类器类型包括根据 grok 模式、XML 标签和 JSON 路径定义架构。
如果您更改一个分类器定义，则之前使用该分类器爬网的任何数据均不会重新分类。爬网程序将跟踪之前爬网的数据。新数据将用更新的分类器来分类，这可能会产生更新的架构。如果数据架构发生了变化，请更新分类器来考虑爬网程序运行时的任何架构更改。要对数据重新分类以更正错误的分类器，请用更新的分类器创建新爬网程序。
有关在 AWS Glue 中创建自定义分类器的更多信息，请参阅[为不同的数据格式编写自定义分类器](custom-classifier.md)。
**注意**
如果您的数据格式可被由某个内置分类器识别，则不需要创建自定义分类器。
## 内置分类器
AWS Glue 为各种格式（包括 JSON、CSV、Web 日志和许多数据库系统）提供内置分类器。
如果 AWS Glue 找不到符合 100% 确定性的输入数据格式的自定义分类器，它会按照下表中所示的顺序调用内置分类器。内置分类器返回结果以指示格式是否匹配 (`certainty=1.0`) 或不匹配 (`certainty=0.0`)。第一个具有 `certainty=1.0` 的分类器为您的数据目录中的元数据表提供分类字符串和架构。
| 分类器类型 | 分类字符串 | 备注 |
| --- | --- | --- |
| Apache Avro | avro | 读取文件开头处的架构以确定格式。 |
| Apache ORC | orc | 读取文件元数据以确定格式。 |
| Apache Parquet | parquet | 读取文件结尾处的架构以确定格式。 |
| JSON | json | 读取文件的开头以确定格式。 |
| 二进制 JSON | bson | 读取文件的开头以确定格式。 |
| XML | xml | 读取文件的开头以确定格式。AWS Glue 根据文档中的 XML 标记确定表架构。 有关创建自定义 XML 分类器以指定文档中的行的信息，请参阅[编写 XML 自定义分类器](custom-classifier.md#custom-classifier-xml)。 |
| Amazon Ion | ion | 读取文件的开头以确定格式。 |
| 组合 Apache 日志 | combined\$1apache | 通过 grok 模式确定日志格式。 |
| Apache 日志 | apache | 通过 grok 模式确定日志格式。 |
| Linux 内核日志 | linux\$1kernel | 通过 grok 模式确定日志格式。 |
| Microsoft 日志 | microsoft\$1log | 通过 grok 模式确定日志格式。 |
| Ruby 日志 | ruby\$1logger | 读取文件的开头以确定格式。 |
| Squid 3.x 日志 | squid | 读取文件的开头以确定格式。 |
| Redis 监控日志 | redismonlog | 读取文件的开头以确定格式。 |
| Redis 日志 | redislog | 读取文件的开头以确定格式。 |
| CSV | csv | 检查以下分隔符：逗号 (,)、竖线 (\$1)、制表符 (\$1t)、分号 (;) 和 Ctrl-A (\$1u0001)。Ctrl-A 是 Start Of Heading 的 Unicode 控制字符。 |
| Amazon Redshift | redshift | 使用 JDBC 连接导入元数据。 |
| MySQL | mysql | 使用 JDBC 连接导入元数据。 |
| PostgreSQL | postgresql | 使用 JDBC 连接导入元数据。 |
| Oracle 数据库 | oracle | 使用 JDBC 连接导入元数据。 |
| Microsoft SQL Server | sqlserver | 使用 JDBC 连接导入元数据。 |
| Amazon DynamoDB | dynamodb | 从 DynamoDB 表中读取数据。 |
以下压缩格式的文件可以分类：
+ ZIP（在只包含单个文件的存档操作中支持此格式）。请注意，Zip 格式在其他服务中不太受支持（由于存档）。
+ BZIP
+ GZIP
+ LZ4
+ Snappy（支持标准和 Hadoop 本机 Snappy 格式）
### 内置的 CSV 分类器
内置的 CSV 分类器可分析 CSV 文件内容，以确定 AWS Glue 表的架构。此分类器会检查以下分隔符：
+ 逗号 (,)
+ 竖线 (\$1)
+ 制表符 (\$1t)
+ 分号 (;)
+ Ctrl-A (\$1u0001)
Ctrl-A 是 `Start Of Heading` 的 Unicode 控制字符。
要被分类为 CSV，表架构必须至少有两列和两行数据。CSV 分类器使用许多探试程序来确定给定中是否存在某一标头。如果分类器无法根据第一行数据确定标头，列标题将显示为 `col1`、`col2`、`col3`，以此类推。内置的 CSV 分类器确定是否通过评估文件的以下特性来推断标头：
+ 潜在标头中的每列均分析为 STRING 数据类型。
+ 除了最后一列外，潜在标头中的每列的内容均少于 150 个字符。要允许尾部的分隔符，在整个文件中最后一列均可为空。
+ 潜在标头中的每列都必须满足列名称的 AWS Glue `regex` 要求。
+ 标题行必须与数据行存在足够差别。为确定这一点，必须将一行或多行分析为 STRING 之外的类型。如果所有列均为 STRING 类型，则第一行数据与后续行差别不够大，无法用作标头。
**注意**
如果内置的 CSV 分类器未创建您需要的 AWS Glue 表，您可能能够使用以下一种方法：
更改数据目录中的列名称，将 `SchemaChangePolicy` 设置为 LOG，为未来的爬网程序运行将分区输出配置设置为 `InheritFromTable`。
创建自定义 grok 分类器，以分析数据并按您所需来分配列。
内置的 CSV 分类器会创建表，同时引用 `LazySimpleSerDe` 作为序列化库，这是进行类型推断的极好选择。但是，如果 CSV 数据包含带引号的字符串，请编辑表定义并将 SerDe 库更改为 `OpenCSVSerDe`。将任何推断类型调整为 STRING，将 `SchemaChangePolicy` 设置为 LOG，为未来的爬网程序运行将分区输出配置设置为 `InheritFromTable`。有关 SerDe 库的更多信息，请参阅 Amazon Athena 用户指南中的 [SerDe 参考](https://docs.aws.amazon.com/athena/latest/ug/serde-reference.html)。
# 为不同的数据格式编写自定义分类器
您可以提供自定义分类器来对 AWS Glue 中的数据进行分类。您可以使用 grok 模式、XML 标签、JavaScript 对象表示法 (JSON) 或逗号分隔值 (CSV) 来创建自定义分类器。AWS Glue 爬网程序调用自定义分类器。如果分类器可识别数据，则它会将数据的分类和架构返回到爬网程序。如果数据与任何内置分类器不匹配，或者您希望自定义由爬网程序创建的表，则可能需要定义自定义分类器。
有关使用 AWS Glue 控制台创建分类器的更多信息，请参阅[使用 AWS Glue 控制台创建分类器](console-classifiers.md)。
AWS Glue 按照您指定的顺序在内置分类器之前运行自定义分类器。当爬网程序找到与数据匹配的分类器时，分类字符串和架构将在写入 AWS Glue Data Catalog的表的定义中使用。
**Topics**
+ [编写 grok 自定义分类器](#custom-classifier-grok)
+ [编写 XML 自定义分类器](#custom-classifier-xml)
+ [编写 JSON 自定义分类器](#custom-classifier-json)
+ [编写 CSV 自定义分类器](#custom-classifier-csv)
## 编写 grok 自定义分类器
Grok 是一个工具，用于分析给定匹配模式的文本数据。grok 模式是一组命名的正则表达式 (regex)，用于一次匹配一行数据。AWS Glue 使用 grok 模式来推断数据的架构。当 grok 模式与您的数据匹配时，AWS Glue 使用该模式来确定数据的结构并将其映射到字段。
AWS Glue 提供许多内置模式，或者您也可以定义自己的模式。您可以使用自定义分类器定义中的内置模式和自定义模式来创建 grok 模式。您可以定制 grok 模式来对自定义文本文件格式进行分类。
**注意**
AWS Glue grok 自定义分类器对在 AWS Glue Data Catalog 中创建的表使用 `GrokSerDe` 序列化库。如果您要将 AWS Glue Data Catalog 与 Amazon Athena、Amazon EMR 或 Redshift Spectrum 结合使用，请参阅有关这些服务的文档以了解有关 `GrokSerDe` 支持的信息。目前，在从 Amazon EMR 和 Redshift Spectrum 查询使用 `GrokSerDe` 创建的表时，您可能会遇到问题。
以下是 grok 模式组件的基本语法：
```
%{PATTERN:field-name}
```
与命名 `PATTERN` 匹配的数据映射到架构中的 `field-name` 列，默认数据类型为 `string`。或者，该字段的数据类型可以在生成的架构中强制转换为 `byte`、`boolean`、`double`、`short`、`int`、`long` 或 `float`。
```
%{PATTERN:field-name:data-type}
```
例如，要将 `num` 字段强制转换为 `int` 数据类型，您可以使用此模式：
```
%{NUMBER:num:int}
```
模式可以是由其他模式组成。例如，您可以为 `SYSLOG` 时间戳指定一个模式，该模式由月份、月份中的日期和时间的模式定义（例如，`Feb 1 06:25:43`）。对于此数据，您可能定义以下模式：
```
SYSLOGTIMESTAMP %{MONTH} +%{MONTHDAY} %{TIME}
```
**注意**
Grok 模式一次只能处理一行。不支持多行模式。此外，不支持模式中的换行符。
### grok 分类器的自定义值
定义 grok 分类器时，可以提供以下值以创建自定义分类器。
**名称**
分类器的名称。
**分类**
写入的文本字符串，用于描述分类数据的格式；例如，`special-logs`。
**Grok 模式**
应用于数据存储以确定是否存在匹配的模式集。这些模式来自 AWS Glue [内置模式](#classifier-builtin-patterns)和您定义的任何自定义模式。
以下是 grok 模式的示例：
```
%{TIMESTAMP_ISO8601:timestamp} \[%{MESSAGEPREFIX:message_prefix}\] %{CRAWLERLOGLEVEL:loglevel} : %{GREEDYDATA:message}
```
当数据与 `TIMESTAMP_ISO8601` 匹配时，将会创建架构列 `timestamp`。此行为与示例中的其他命名模式类似。
**自定义模式**
您定义的可选自定义模式。这些模式由对您的数据进行分类的 grok 模式引用。您可以在应用于您的数据的 grok 模式中引用这些自定义模式。每个自定义组件模式必须位于不同的行上。[正则表达式 (regex)](http://en.wikipedia.org/wiki/Regular_expression) 语法用于定义模式。
下面是如何使用自定义模式的示例：
```
CRAWLERLOGLEVEL (BENCHMARK|ERROR|WARN|INFO|TRACE)
MESSAGEPREFIX .*-.*-.*-.*-.*
```
第一个自定义命名模式 `CRAWLERLOGLEVEL` 在数据与其中一个枚举字符串匹配时是匹配项。第二个自定义模式 `MESSAGEPREFIX` 尝试匹配消息前缀字符串。
AWS Glue 跟踪分类器的创建时间、上次更新时间和版本。
### 内置模式
AWS Glue 可提供许多常见模式，您可以用来构建自定义分类器。您将在分类器定义中向 `grok pattern` 添加命名模式。
以下列表为每个模式包含一行。在每个行中，模式名称遵循其定义。[正则表达式 (regex)](http://en.wikipedia.org/wiki/Regular_expression) 语法用于定义模式。
```
#&GLU; Built-in patterns
USERNAME [a-zA-Z0-9._-]+
USER %{USERNAME:UNWANTED}
INT (?:[+-]?(?:[0-9]+))
BASE10NUM (?[+-]?(?:(?:[0-9]+(?:\.[0-9]+)?)|(?:\.[0-9]+)))
NUMBER (?:%{BASE10NUM:UNWANTED})
BASE16NUM (?(?"(?>\\.|[^\\"]+)+"|""|(?>'(?>\\.|[^\\']+)+')|''|(?>`(?>\\.|[^\\`]+)+`)|``))
UUID [A-Fa-f0-9]{8}-(?:[A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}
# Networking
MAC (?:%{CISCOMAC:UNWANTED}|%{WINDOWSMAC:UNWANTED}|%{COMMONMAC:UNWANTED})
CISCOMAC (?:(?:[A-Fa-f0-9]{4}\.){2}[A-Fa-f0-9]{4})
WINDOWSMAC (?:(?:[A-Fa-f0-9]{2}-){5}[A-Fa-f0-9]{2})
COMMONMAC (?:(?:[A-Fa-f0-9]{2}:){5}[A-Fa-f0-9]{2})
IPV6 ((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?
IPV4 (?/(?>[\w_%!$@:.,~-]+|\\.)*)+
#UNIXPATH (?[A-Za-z]+:|\\)(?:\\[^\\?*]*)+
URIPROTO [A-Za-z]+(\+[A-Za-z+]+)?
URIHOST %{IPORHOST}(?::%{POSINT:port})?
# uripath comes loosely from RFC1738, but mostly from what Firefox
# doesn't turn into %XX
URIPATH (?:/[A-Za-z0-9$.+!*'(){},~:;=@#%_\-]*)+
#URIPARAM \?(?:[A-Za-z0-9]+(?:=(?:[^&]*))?(?:&(?:[A-Za-z0-9]+(?:=(?:[^&]*))?)?)*)?
URIPARAM \?[A-Za-z0-9$.+!*'|(){},~@#%&/=:;_?\-\[\]]*
URIPATHPARAM %{URIPATH}(?:%{URIPARAM})?
URI %{URIPROTO}://(?:%{USER}(?::[^@]*)?@)?(?:%{URIHOST})?(?:%{URIPATHPARAM})?
# Months: January, Feb, 3, 03, 12, December
MONTH \b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\b
MONTHNUM (?:0?[1-9]|1[0-2])
MONTHNUM2 (?:0[1-9]|1[0-2])
MONTHDAY (?:(?:0[1-9])|(?:[12][0-9])|(?:3[01])|[1-9])
# Days: Monday, Tue, Thu, etc...
DAY (?:Mon(?:day)?|Tue(?:sday)?|Wed(?:nesday)?|Thu(?:rsday)?|Fri(?:day)?|Sat(?:urday)?|Sun(?:day)?)
# Years?
YEAR (?>\d\d){1,2}
# Time: HH:MM:SS
#TIME \d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?
# TIME %{POSINT<24}:%{POSINT<60}(?::%{POSINT<60}(?:\.%{POSINT})?)?
HOUR (?:2[0123]|[01]?[0-9])
MINUTE (?:[0-5][0-9])
# '60' is a leap second in most time standards and thus is valid.
SECOND (?:(?:[0-5]?[0-9]|60)(?:[:.,][0-9]+)?)
TIME (?!<[0-9])%{HOUR}:%{MINUTE}(?::%{SECOND})(?![0-9])
# datestamp is YYYY/MM/DD-HH:MM:SS.UUUU (or something like it)
DATE_US %{MONTHNUM}[/-]%{MONTHDAY}[/-]%{YEAR}
DATE_EU %{MONTHDAY}[./-]%{MONTHNUM}[./-]%{YEAR}
DATESTAMP_US %{DATE_US}[- ]%{TIME}
DATESTAMP_EU %{DATE_EU}[- ]%{TIME}
ISO8601_TIMEZONE (?:Z|[+-]%{HOUR}(?::?%{MINUTE}))
ISO8601_SECOND (?:%{SECOND}|60)
TIMESTAMP_ISO8601 %{YEAR}-%{MONTHNUM}-%{MONTHDAY}[T ]%{HOUR}:?%{MINUTE}(?::?%{SECOND})?%{ISO8601_TIMEZONE}?
TZ (?:[PMCE][SD]T|UTC)
DATESTAMP_RFC822 %{DAY} %{MONTH} %{MONTHDAY} %{YEAR} %{TIME} %{TZ}
DATESTAMP_RFC2822 %{DAY}, %{MONTHDAY} %{MONTH} %{YEAR} %{TIME} %{ISO8601_TIMEZONE}
DATESTAMP_OTHER %{DAY} %{MONTH} %{MONTHDAY} %{TIME} %{TZ} %{YEAR}
DATESTAMP_EVENTLOG %{YEAR}%{MONTHNUM2}%{MONTHDAY}%{HOUR}%{MINUTE}%{SECOND}
CISCOTIMESTAMP %{MONTH} %{MONTHDAY} %{TIME}
# Syslog Dates: Month Day HH:MM:SS
SYSLOGTIMESTAMP %{MONTH} +%{MONTHDAY} %{TIME}
PROG (?:[\w._/%-]+)
SYSLOGPROG %{PROG:program}(?:\[%{POSINT:pid}\])?
SYSLOGHOST %{IPORHOST}
SYSLOGFACILITY <%{NONNEGINT:facility}.%{NONNEGINT:priority}>
HTTPDATE %{MONTHDAY}/%{MONTH}/%{YEAR}:%{TIME} %{INT}
# Shortcuts
QS %{QUOTEDSTRING:UNWANTED}
# Log formats
SYSLOGBASE %{SYSLOGTIMESTAMP:timestamp} (?:%{SYSLOGFACILITY} )?%{SYSLOGHOST:logsource} %{SYSLOGPROG}:
MESSAGESLOG %{SYSLOGBASE} %{DATA}
COMMONAPACHELOG %{IPORHOST:clientip} %{USER:ident} %{USER:auth} \[%{HTTPDATE:timestamp}\] "(?:%{WORD:verb} %{NOTSPACE:request}(?: HTTP/%{NUMBER:httpversion})?|%{DATA:rawrequest})" %{NUMBER:response} (?:%{Bytes:bytes=%{NUMBER}|-})
COMBINEDAPACHELOG %{COMMONAPACHELOG} %{QS:referrer} %{QS:agent}
COMMONAPACHELOG_DATATYPED %{IPORHOST:clientip} %{USER:ident;boolean} %{USER:auth} \[%{HTTPDATE:timestamp;date;dd/MMM/yyyy:HH:mm:ss Z}\] "(?:%{WORD:verb;string} %{NOTSPACE:request}(?: HTTP/%{NUMBER:httpversion;float})?|%{DATA:rawrequest})" %{NUMBER:response;int} (?:%{NUMBER:bytes;long}|-)
# Log Levels
LOGLEVEL ([A|a]lert|ALERT|[T|t]race|TRACE|[D|d]ebug|DEBUG|[N|n]otice|NOTICE|[I|i]nfo|INFO|[W|w]arn?(?:ing)?|WARN?(?:ING)?|[E|e]rr?(?:or)?|ERR?(?:OR)?|[C|c]rit?(?:ical)?|CRIT?(?:ICAL)?|[F|f]atal|FATAL|[S|s]evere|SEVERE|EMERG(?:ENCY)?|[Ee]merg(?:ency)?)
```
## 编写 XML 自定义分类器
XML 使用文件中的标签定义文档的结构。使用 XML 自定义分类器，您可以指定用于定义行的标签名称。
### XML 分类器的自定义分类器值
定义 XML 分类器时，可以向 AWS Glue 提供以下值以创建分类器。此分类器的分类字段设置为 `xml`。
**名称**
分类器的名称。
**行标签**
在 XML 文档中定义表行的 XML 标记名称，不带尖括号 `< >`.. 名称必须符合标签的 XML 规则。
包含行数据的元素**不能**是自结束的空元素。例如，** **不AWS Glue解析此空元素：
```
|
```
可以如下所示编写空元素：
```
```
AWS Glue 跟踪分类器的创建时间、上次更新时间和版本。
例如，假设您具有以下 XML 文件。要创建仅包含作者和标题列的 AWS Glue 表，请在 AWS Glue 控制台中创建 **Row tag (行标签)** 为 `AnyCompany` 的分类器。然后，添加并运行使用此自定义分类器的爬网程序。
```
Rivera, Martha
AnyCompany Developer Guide
Stiles, John
Style Guide for AnyCompany
```
## 编写 JSON 自定义分类器
JSON 一种数据交换格式。它使用名称-值对或值的有序列表来定义数据结构。使用 JSON 自定义分类器，您可以指定用于为表定义架构的数据结构的 JSON 路径。
### AWS Glue 中的自定义分类器值
定义 JSON 分类器时，可以向 AWS Glue 提供以下值以创建分类器。此分类器的分类字段设置为 `json`。
**名称**
分类器的名称。
**JSON 路径**
一个 JSON 路径，指向用于定义表架构的对象。JSON 路径可以用点表示法或括号表示法编写。支持以下运算符：
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/custom-classifier.html)
AWS Glue 跟踪分类器的创建时间、上次更新时间和版本。
**Example 使用 JSON 分类器从数组中提取记录**
假设您的 JSON 数据是一组记录。例如，您的文件的前几行可能如下所示：
```
[
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ak",
"name": "Alaska"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:1",
"name": "Alabama's 1st congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:2",
"name": "Alabama's 2nd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:3",
"name": "Alabama's 3rd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:4",
"name": "Alabama's 4th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:5",
"name": "Alabama's 5th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:6",
"name": "Alabama's 6th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:7",
"name": "Alabama's 7th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:1",
"name": "Arkansas's 1st congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:2",
"name": "Arkansas's 2nd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:3",
"name": "Arkansas's 3rd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:4",
"name": "Arkansas's 4th congressional district"
}
]
```
使用内置 JSON 分类器运行爬网程序时，整个文件用于定义架构。由于您没有指定 JSON 路径，爬网程序将数据视为一个对象，即只是一个数组。例如，架构可能如下所示：
```
root
|-- record: array
```
但是，要创建一个基于 JSON 数组中的每个记录的架构，请创建一个自定义 JSON 分类器，并将 JSON 路径指定为 `$[*]`。当您指定此 JSON 路径时，分类器会询问数组中的所有 12 个记录以确定架构。生成的架构包含每个对象的单独字段，类似于以下示例：
```
root
|-- type: string
|-- id: string
|-- name: string
```
**Example 使用 JSON 分类器仅检查文件的一部分**
假设 JSON 数据遵循来自 [http://everypolitician.org/](http://everypolitician.org/) 的示例 JSON 文件 `s3://awsglue-datasets/examples/us-legislators/all/areas.json` 的模式。JSON 文件中的示例对象如下所示：
```
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ak",
"name": "Alaska"
}
{
"type": "constituency",
"identifiers": [
{
"scheme": "dmoz",
"identifier": "Regional\/North_America\/United_States\/Alaska\/"
},
{
"scheme": "freebase",
"identifier": "\/m\/0hjy"
},
{
"scheme": "fips",
"identifier": "US02"
},
{
"scheme": "quora",
"identifier": "Alaska-state"
},
{
"scheme": "britannica",
"identifier": "place\/Alaska"
},
{
"scheme": "wikidata",
"identifier": "Q797"
}
],
"other_names": [
{
"lang": "en",
"note": "multilingual",
"name": "Alaska"
},
{
"lang": "fr",
"note": "multilingual",
"name": "Alaska"
},
{
"lang": "nov",
"note": "multilingual",
"name": "Alaska"
}
],
"id": "ocd-division\/country:us\/state:ak",
"name": "Alaska"
}
```
使用内置 JSON 分类器运行爬网程序时，整个文件用于创建架构。您最后可能会得到一个如下所示的架构：
```
root
|-- type: string
|-- id: string
|-- name: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
```
但是，要仅使用“`id`”对象创建架构，请创建自定义 JSON 分类器，并将 JSON 路径指定为 `$.id`。然后，该架构仅基于“`id`”字段：
```
root
|-- record: string
```
用此架构提取的前几行数据如下所示：
```
{"record": "ocd-division/country:us/state:ak"}
{"record": "ocd-division/country:us/state:al/cd:1"}
{"record": "ocd-division/country:us/state:al/cd:2"}
{"record": "ocd-division/country:us/state:al/cd:3"}
{"record": "ocd-division/country:us/state:al/cd:4"}
{"record": "ocd-division/country:us/state:al/cd:5"}
{"record": "ocd-division/country:us/state:al/cd:6"}
{"record": "ocd-division/country:us/state:al/cd:7"}
{"record": "ocd-division/country:us/state:ar/cd:1"}
{"record": "ocd-division/country:us/state:ar/cd:2"}
{"record": "ocd-division/country:us/state:ar/cd:3"}
{"record": "ocd-division/country:us/state:ar/cd:4"}
{"record": "ocd-division/country:us/state:as"}
{"record": "ocd-division/country:us/state:az/cd:1"}
{"record": "ocd-division/country:us/state:az/cd:2"}
{"record": "ocd-division/country:us/state:az/cd:3"}
{"record": "ocd-division/country:us/state:az/cd:4"}
{"record": "ocd-division/country:us/state:az/cd:5"}
{"record": "ocd-division/country:us/state:az/cd:6"}
{"record": "ocd-division/country:us/state:az/cd:7"}
```
要在 JSON 文件中基于深层嵌套对象（如“`identifier`”）创建架构，可以创建自定义 JSON 分类器，并将 JSON 路径指定为 `$.identifiers[*].identifier`。尽管该架构与上一个示例类似，但它基于 JSON 文件中的另一个对象。
此架构看上去与下类似：
```
root
|-- record: string
```
如果列出表中的前几行数据，则会指示架构基于“`identifier`”对象中的数据：
```
{"record": "Regional/North_America/United_States/Alaska/"}
{"record": "/m/0hjy"}
{"record": "US02"}
{"record": "5879092"}
{"record": "4001016-8"}
{"record": "destination/alaska"}
{"record": "1116270"}
{"record": "139487266"}
{"record": "n79018447"}
{"record": "01490999-8dec-4129-8254-eef6e80fadc3"}
{"record": "Alaska-state"}
{"record": "place/Alaska"}
{"record": "Q797"}
{"record": "Regional/North_America/United_States/Alabama/"}
{"record": "/m/0gyh"}
{"record": "US01"}
{"record": "4829764"}
{"record": "4084839-5"}
{"record": "161950"}
{"record": "131885589"}
```
要在 JSON 文件中基于另一个深层嵌套对象（如“`name`”数组中的“`other_names`”字段）创建表，可以创建自定义 JSON 分类器，并将 JSON 路径指定为 `$.other_names[*].name`。尽管该架构与上一个示例类似，但它基于 JSON 文件中的另一个对象。此架构看上去与下类似：
```
root
|-- record: string
```
如果列出表中的前几行数据，则会指示它基于“`name`”数组中的“`other_names`”对象中的数据：
```
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Аляска"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "ألاسكا"}
{"record": "ܐܠܐܣܟܐ"}
{"record": "الاسكا"}
{"record": "Alaska"}
{"record": "Alyaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Штат Аляска"}
{"record": "Аляска"}
{"record": "Alaska"}
{"record": "আলাস্কা"}
```
## 编写 CSV 自定义分类器
自定义 CSV 分类器允许您在自定义 CSV 分类器字段中为每列指定数据类型。您可以指定每列的数据类型，用逗号分隔。通过指定数据类型，您可以覆盖爬网程序推断出的数据类型，并确保对数据进行适当分类。
您可以设置用于在分类器中处理 CSV 的 SerDe，该分类器将应用于 Data Catalog。
创建自定义分类器时，您也可以将该分类器重复用于不同的爬网程序。
+ 对于只有标题（无数据）的 CSV 文件，由于提供的信息不足，这些文件将被归类为 UNKNOWN。如果您在*列标题*选项中指定 CSV“有标题”，并提供数据类型，我们可以正确地对这些文件进行分类。
您可以使用自定义 CSV 分类器来推断各种类型的 CSV 数据的架构。您可以为分类器提供的自定义属性包括分隔符、CSV SerDe 选项、有关标题的选项以及是否对数据执行某些验证。
### AWS Glue 中的自定义分类器值
定义 CSV 分类器时，可以向 AWS Glue 提供以下值以创建分类器。此分类器的分类字段设置为 `csv`。
**分类器名称**
分类器的名称。
**CSV Serde**
设置用于在分类器中处理 CSV 的 SerDe，该分类器将应用于 Data Catalog。选项包括“Open CSV SerDe”、“Lazy Simple SerDe”和“无”。当您想让爬网程序执行检测时，可以指定“无”值。
**列分隔符**
一个自定义符号，表示分隔行中每个列条目的内容。提供一个 Unicode 字符。如果您无法键入分隔符，则可以将其复制并粘贴。这适用于可打印字符，包括您的系统不支持的字符（通常显示为 □）。
**引用符号**
一个自定义符号，表示将内容组合为单个列值的内容。必须与列分隔符不同。提供一个 Unicode 字符。如果您无法键入分隔符，则可以将其复制并粘贴。这适用于可打印字符，包括您的系统不支持的字符（通常显示为 □）。
**列标题**
指示有关应如何在 CSV 文件中检测列标题的行为。如果您的自定义 CSV 文件包含列标题，请输入列标题的逗号分隔列表。
**处理选项：允许具有单列的文件**
允许处理仅包含一列的文件。
**处理选项：在标识列值之前去除空格**
指定是否在标识列值类型之前去除值。
**自定义数据类型 - *可选***
输入用逗号分隔的自定义数据类型。在 CSV 文件中指定自定义数据类型。自定义数据类型必须为受支持的数据类型。受支持的数据类型有：“BINARY”、“BOOLEAN”、“DATE”、“DECIMAL”、“DOUBLE”、“FLOAT”、“INT”、“LONG”、“SHORT”、“STRING”、“TIMESTAMP”。不受支持的数据类型将显示错误。
# 使用 AWS Glue 控制台创建分类器
分类器确定您的数据架构。您可以编写一个自定义分类器并从 AWS Glue 指向该分类器。
## 创建分类器
要在 AWS Glue 控制台中添加分类器，请选择 **Add classifier (添加分类器)**。在定义分类器时，您需要提供以下项目的值：
+ **分类器名称** – 为您的分类器提供唯一名称。
+ **分类器类型** – 由此分类器推断的表的分类类型。
+ **上次更新** – 上次更新此分类器的时间。
**分类器名称**
为您的分类器提供唯一名称。
**分类器类型**
选择要创建的分类器的类型。
根据您选择的分类器类型，为分类器配置以下属性：
------
#### [ Grok ]
+ **分类。**
描述分类的数据的格式或类型或提供自定义标签。
+ **Grok 模式**
此模式用于将您的数据解析为结构化架构。Grok 模式由描述您数据存储格式的命名模式组成。您使用 AWS Glue 提供的已命名内置模式和您编写且包含在 **Custom patterns (自定义模式)** 字段中的自定义模式编写此 grok 模式。尽管 grok 调试程序结果可能不完全匹配 AWS Glue 中的结果，我们仍建议您使用一些示例数据与 grok 调试程序来尝试您的模式。您可以在 Web 上查找 grok 调试程序。AWS Glue 提供的已命名的内置模式通常可与 Web 上提供的 grok 模式兼容。
通过以迭代方式添加已命名的模式来构建您的 grok 模式，并在调试程序中检查您的结果。此活动将使您确信，当 AWS Glue 爬网程序运行 grok 模式时会解析您的数据。
+ **自定义模式**
对于 grok 分类器，这些是您编写的 **Grok pattern** (Grok 模式) 的可选构建块。当内置模式无法解析您的数据时，您可能需要编写自定义模式。这些自定义模式在此字段中定义并在 **Grok pattern** (Grok 模式) 字段中引用。每个自定义模式在单独的行上定义。和内置模式一样，它包含一个已命名的模式定义，该定义使用[正则表达式 (regex)](http://en.wikipedia.org/wiki/Regular_expression) 语法。
例如，以下是具有名称 `MESSAGEPREFIX` 后跟要应用于您的数据以确定其是否符合该模式的正则表达式定义。
```
MESSAGEPREFIX .*-.*-.*-.*-.*
```
------
#### [ XML ]
+ **行标签**
对于 XML 分类器，这是定义 XML 文档中的表行的 XML 标签的名称。键入名称，不带尖括号 `< >`。名称必须符合标签的 XML 规则。
有关更多信息，请参阅 [编写 XML 自定义分类器](custom-classifier.md#custom-classifier-xml)。
------
#### [ JSON ]
+ **JSON 路径**
对于 JSON 分类器，这是定义正在创建的表的行的对象、数组或值的 JSON 路径。使用 AWS Glue 支持的运算符在点或括号 JSON 语法中键入名称。
有关更多信息，请参阅[编写 JSON 自定义分类器](custom-classifier.md#custom-classifier-json)中的运算符列表。
------
#### [ CSV ]
+ **列分隔符**
单个字符或符号，表示分隔行中每个列条目的内容。从列表中选择分隔符，或选择 `Other` 来输入自定义分隔符。
+ **引用符号**
单个字符或符号，表示将内容组合为单个列值的内容。必须与列分隔符不同。从列表中选择引用符号，或选择 `Other` 来输入自定义引用字符。
+ **列标题**
指示有关应如何在 CSV 文件中检测列标题的行为。您可以选择 `Has headings`、`No headings` 或 `Detect headings`。如果您的自定义 CSV 文件包含列标题，请输入列标题的逗号分隔列表。
+ **允许具有单列的文件**
要被分类为 CSV，数据必须至少有两列和两行数据。使用此选项处理仅包含一列的文件。
+ **在标识列值之前去除空格**
此选项指定是否在标识列值类型之前去除值。
+ **自定义数据类型**
（可选）- 在逗号分隔列表中输入自定义数据类型。受支持的数据类型有：“BINARY”、“BOOLEAN”、“DATE”、“DECIMAL”、“DOUBLE”、“FLOAT”、“INT”、“LONG”、“SHORT”、“STRING”、“TIMESTAMP”。
+ **CSV Serde**
（可选）- 设置用于在分类器中处理 CSV 的 SerDe，该分类器将应用于 Data Catalog。可以选择 `Open CSV SerDe`、`Lazy Simple SerDe` 或 `None`。当您想让爬网程序执行检测时，可以指定 `None` 值。
------
有关更多信息，请参阅 [为不同的数据格式编写自定义分类器](custom-classifier.md)。
## 查看分类器
要查看您创建的所有分类器的列表，请点击 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 打开 AWS Glue 控制台，然后选择 **Classifiers (分类器)** 选项卡。
列表显示了有关每个分类器的以下属性：
+ **分类器** – 分类器名称。创建分类器时，您必须为其提供名称。
+ **分类** – 由此分类器推断的表的分类类型。
+ **上次更新** – 上次更新此分类器的时间。
## 管理分类器
从 ** 控制台中的 **ClassifiersAWS Glue (分类器) 列表中，您可以添加、编辑和删除分类器。要查看分类器的详细信息，请在列表中选择分类器名称。详细信息包括您创建分类器时定义的信息。
# 配置爬网程序
爬网程序访问您的数据存储，标识元数据并在 AWS Glue Data Catalog 中创建表定义。AWS Glue 控制台中的 **Crawlers (爬网程序)** 窗格列出了您创建的所有爬网程序。此列表显示上次运行的爬网程序的状态和指标。
本主题包含配置爬网程序的分步过程，涵盖设置爬网程序参数、定义要爬取的数据来源、设置安全性以及管理已爬取的数据等基本方面。
**Topics**
+ [步骤 1：设置爬网程序属性](define-crawler-set-crawler-properties.md)
+ [步骤 2：选择数据源和分类器](define-crawler-choose-data-sources.md)
+ [步骤 3：配置安全设置](define-crawler-configure-security-settings.md)
+ [步骤 4：设置输出和计划](define-crawler-set-output-and-scheduling.md)
+ [第 5 步：审核并创建](define-crawler-review.md)
# 步骤 1：设置爬网程序属性
**配置爬网程序**
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\)。在导航窗格中选择 **Crawlers (爬网程序)**。
1. 选择**添加爬网程序**，然后按照**添加爬网程序**向导中的说明进行操作。该向导将引导您完成创建爬网程序所需的步骤。如果要添加自定义分类器来定义架构，请参阅[定义和管理分类器](add-classifier.md)。
1. 为您的爬网程序输入名称和描述（可选）。（可选）您可以使用 **Tag key (标签键)** 和可选的 **Tag value (标签值)** 来标记爬网程序。创建之后，标签键处于只读状态。对某些资源使用标签可帮助您整理和标识资源。有关更多信息，请参阅 AWS Glue 中的 AWS 标签。
**名称**
名称可以包含字母 (A-Z)、数字 (0-9)、连字符 (-)、或下划线 (\$1)，且长度最多为 255 个字符。
**描述**
描述长度最多为 2048 个字符。
**标签**
使用标签来组织和标识资源。有关更多信息，请参阅下列内容：
+ [AWS Glue 中的 AWS 标签](monitor-tags.md)
# 步骤 2：选择数据源和分类器
接下来，为爬网程序配置数据来源和分类器。
有关支持的数据来源的更多信息，请参阅[支持的可供爬取的数据来源](crawler-data-stores.md)。
**数据来源配置**
为**您的数据是否已映射到 AWS Glue 表？**选择相应的选项，选择“尚未”或“是”。默认情况下已选择“尚未”。
爬网程序可以直接访问数据存储作为爬取的源，也可以使用数据目录中的现有表作为源。如果爬网程序使用现有目录表，它将爬取由这些目录表指定的数据存储。
+ 还没有：选择一个或多个要爬取的数据源。一个爬网程序可以爬取多个不同类型的数据存储（Amazon S3、JDBC 等）。
您一次只能配置一个数据存储。提供连接信息并包含路径和排除模式后，您可以选择添加另一个数据存储。
+ 是：从您的 AWS Glue 数据目录中选择现有表。目录表指定要爬取的数据存储。爬网程序在单次运行中只能爬取目录表；它无法混用其他源类型。
将目录表指定为源的常见原因是在您手动创建该表（因为您已经知道数据存储的结构）时，您希望爬网程序让表保持更新，包括添加新分区。有关其他原因的讨论，请参阅[使用爬网程序更新手动创建的数据目录表](tables-described.md#update-manual-tables)。
当您指定现有表作为爬网程序源类型时，以下条件适用：
+ 数据库名称是可选的。
+ 仅允许指定 Amazon S3、Amazon DynamoDB 或 Delta Lake 数据存储的目录表。
+ 爬网程序运行时，不会创建新的目录表。根据需要更新现有表，包括添加新分区。
+ 将忽略在数据存储中找到的已删除对象；不删除目录表。而是由爬网程序写入日志消息。(`SchemaChangePolicy.DeleteBehavior=LOG`)
+ 默认情况下启用为每个 Amazon S3 路径创建单一架构的爬网程序配置选项，且不能禁用此选项。（`TableGroupingPolicy`=`CombineCompatibleSchemas`）有关更多信息，请参阅[为每条 Amazon S3 包含路径创建单个架构](crawler-grouping-policy.md)。
+ 您不能将目录表与任何其他源类型（例如 Amazon S3 或 Amazon DynamoDB）混用来作为源。
要使用 Delta 表，请首先使用 Athena DDL 或 AWS Glue API 创建一个 Delta 表。
使用 Athena 时，请将位置设置为您的 Amazon S3 文件夹，将表类型设置为“DELTA”。
```
CREATE EXTERNAL TABLE database_name.table_name
LOCATION 's3://bucket/folder/'
TBLPROPERTIES ('table_type' = 'DELTA')
```
使用 AWS Glue API 时，请在表参数映射中指定表类型。表参数需要包含以下键/值对。有关如何创建表的更多信息，请参阅[有关 create\$1table 的 Boto3 文档](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/glue/client/create_table.html)。
```
{
"table_type":"delta"
}
```
**数据来源**
选择或添加要由爬网程序扫描的数据源列表。
（可选）如果选择 JDBC 作为数据来源，则在指定存储驱动程序信息的连接访问权限时，可以使用自己的 JDBC 驱动程序。
**包含路径**
在评估要在爬取中包含或排除的内容时，爬网程序首先评估所需的包含路径。对于 Amazon S3、MongoDB、MongoDB Atlas、Amazon DocumentDB（与 MongoDB 兼容）和关系数据存储，您必须指定包含路径。
对于 Amazon S3 数据存储
选择是在此账户还是其他账户中指定路径，然后浏览以选择 Amazon S3 路径。
对于 Amazon S3 数据存储，包含路径语法为 `bucket-name/folder-name/file-name.ext`。要网络爬取存储桶中的所有对象，只需在包含路径中指定存储桶名称。排除模式与包含路径是相对的
对于 Delta Lake 数据存储
将一个或多个指向 Delta 表的 Amazon S3 路径，格式为 s3://*bucket*/*prefix*/*object*。
适用于 Iceberg 或 Hudi 数据存储
指定一个或多个包含 Iceberg 或 Hudi 表元数据为 s3://*bucket*/*prefix* 的文件夹的 Amazon S3 路径。
对于 Iceberg 和 Hudi 数据存储，Iceberg/Hudi 文件夹可能位于根文件夹的子文件夹中。爬网程序将扫描路径下的所有文件夹，寻找 Hudi 文件夹。
对于 JDBC 数据存储
输入 **/**/** 或 **/**，具体取决于数据库产品。Oracle Database 和 MySQL 不支持路径中的架构。您可以用百分比 (%) 字符替换 ** 或 **。例如，对于系统标识符 (SID) 为 `orcl` 的 Oracle 数据库，输入 `orcl/%` 以导入连接中指定的用户有权访问的所有表。
此字段区分大小写。
如果您选择引入自己的 JDBC 驱动程序版本，则 AWS Glue 爬网程序将消耗 AWS Glue 作业 和 Amazon S3 存储桶中的资源，以确保您提供的驱动程序在您的环境中运行。额外的资源使用量将反映在您的账户中。驱动程序仅限于[添加 AWS Glue 连接](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html)中描述的属性。
对于 MongoDB、MongoDB Atlas 或 Amazon DocumentDB 数据存储
对于 MongoDB、MongoDB Atlas 和 Amazon DocumentDB（与 MongoDB 兼容），语法为 `database/collection`。
对于 JDBC 数据存储，语法为 `database-name/schema-name/table-name` 或 `database-name/table-name`。语法取决于数据库引擎是否支持数据库中的架构。例如，对于 MySQL 或 Oracle 等数据库引擎，请不要在包含路径中指定 `schema-name`。您可以用百分号 (`%`) 取代包含路径中的架构或表，以表示数据库中的所有架构或所有表。您不能用百分号 (`%`) 取代包含路径中的数据库。
**最大遍历深度（仅适用于 Iceberg 或 Hudi 数据存储）**
定义爬网程序可以遍历的最大 Amazon S3 路径深度，以发现 Amazon S3 路径中的 Iceberg 或 Hudi 元数据文件夹。此参数的目的是限制爬网程序的运行时间。默认值为 10；最大值为 20。
**排除模式**
您可以使用这些模式从爬取中排除某些文件或表。排除路径与包含路径是相对的。例如，要排除 JDBC 数据存储中的一个表，请在排除路径中键入该表的名称。
爬网程序使用包含 JDBC URI 连接字符串的 AWS Glue 连接连接到 JDBC 数据存储。该爬网程序只能使用 AWS Glue 连接中的 JDBC 用户名和密码来访问数据库引擎中的对象。*爬网程序只能创建它通过 JDBC 连接可以访问的表。*在爬网程序使用 JDBC URI 访问数据库引擎后，包含路径用于确定在数据目录中创建了数据库引擎中的哪些表。例如，对于 MySQL，如果您指定包含路径 `MyDatabase/%`，则 `MyDatabase` 中的所有表都是在数据目录中创建的。访问 Amazon Redshift 时，如果您指定包含路径 `MyDatabase/%`，则数据库 `MyDatabase` 的所有架构中的所有表都是在数据目录中创建的。如果您指定包含路径 `MyDatabase/MySchema/%`，则会创建数据库 `MyDatabase` 和架构 `MySchema` 中的所有表。
指定包含路径后，您可以通过指定一个或多个 Unix 样式 `glob` 排除模式，从网络爬取中排除对象 (否则您的包含路径会包括它)。这些模式应用于您的包含路径，以确定哪些对象被排除。这些模式也会存储为由爬网程序创建的表的属性。AWS GluePySpark 扩展（例如 `create_dynamic_frame.from_catalog`）读取表属性并排除由排除模式定义的对象。
AWS Glue 在排除模式中支持以下 `glob` 模式。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/define-crawler-choose-data-sources.html)
AWS Glue 解释 `glob` 排除模式，如下所示：
+ 斜杠（`/`）字符是将 Amazon S3 密钥分隔到文件夹层次结构中的分隔符。
+ 星号 (`*`) 字符与不跨越文件夹边界的名称组分的零个或多个字符匹配。
+ 双星号 (`**`) 与跨越文件夹或架构边界的零个或多个字符匹配。
+ 问号 (`?`) 字符恰好匹配名称组分的一个字符。
+ 反斜杠 (`\`) 字符用于对其他可以解释为特殊字符的字符进行转义。表达式 `\\` 与单个反斜杠匹配，`\{` 与左大括号匹配。
+ 方括号 `[ ]` 创建一个与名称组分的单个字符 (来自一组字符) 匹配的方括号表达式。例如，`[abc]` 与 `a`、`b` 或 `c` 匹配。连字符 (`-`) 可用于指定范围，因此 `[a-z]` 指定与从 `a` 到 `z` (含) 的范围匹配。这些形式可以混合，因此 [`abce-g`] 与 `a`、`b`、`c`、`e`、`f` 或 `g` 匹配。如果方括号 (`[`) 后的字符是感叹号 (`!`)，则括号表达式是否定的。例如，`[!a-c]` 与 `a`、`b` 或 `c` 以外的任何字符匹配。
在方括号表达式内，`*`、`?` 和 `\` 字符与自身匹配。如果连字符 (`-`) 是方括号内的第一个字符，或者如果它在您否定时是 `!` 之后的第一个字符，则它与自身匹配。
+ 大括号 (`{ }`) 将一组子模式 (如果组中的任何子模式匹配，则组匹配) 括起来。逗号 (`,`) 字符用于分隔子模式。不能对组进行嵌套。
+ 在匹配操作中，文件名中的前导句点或点字符被视为正常字符。例如，`*` 排除与文件名 `.hidden` 匹配的模式。
**Example Amazon S3 排除模式**
将会根据包含路径计算每个排除模式。例如，假设您具有以下 Amazon S3 目录结构：
```
/mybucket/myfolder/
departments/
finance.json
market-us.json
market-emea.json
market-ap.json
employees/
hr.json
john.csv
jane.csv
juan.txt
```
假定包含路径 `s3://mybucket/myfolder/`，下面是排除模式的一些示例结果：
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/define-crawler-choose-data-sources.html)
**Example 排除 Amazon S3 分区的子集**
假设数据按天进行分区，以便一年中的每一天都在单独的 Amazon S3 分区中。对于 2015 年 1 月，有 31 个分区。现在，若要仅网络爬取 1 月的第一周内的数据，您必须排除除第 1 到第 7 天之外的所有分区：
```
2015/01/{[!0],0[8-9]}**, 2015/0[2-9]/**, 2015/1[0-2]/**
```
让我们来看一下此 glob 模式的几个部分。第一部分 ` 2015/01/{[!0],0[8-9]}**` 排除不以“0”开头的所有天，以及 2015 年 01 月中的第 08 和第 09 天。请注意，“\$1\$1”用作日期数字模式的后缀，并穿越文件夹边界直到较低级别的文件夹。如果使用“\$1”，则不排除较低文件夹级别。
第二部分 ` 2015/0[2-9]/**` 排除 2015 年 02 月 09 月中的天。
第三部分 `2015/1[0-2]/**` 排除 2015 年 10、11 和 12 月中的天。
**Example JDBC 排除模式**
假设您使用以下架构结构网络爬取 JDBC 数据库：
```
MyDatabase/MySchema/
HR_us
HR_fr
Employees_Table
Finance
Market_US_Table
Market_EMEA_Table
Market_AP_Table
```
假定包含路径 `MyDatabase/MySchema/%`，下面是排除模式的一些示例结果：
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/define-crawler-choose-data-sources.html)
**其他爬网程序源参数**
每种源类型都需要一组不同的附加参数。
**Connection**
选择或添加 AWS Glue 连接。有关连接的信息，请参阅 [连接到数据](glue-connections.md)。
**其他元数据 — 可选（适用于 JDBC 数据存储）**
选择爬网程序要爬取的其他元数据属性。
+ 注释：爬取相关的表级和列级注释。
+ 原始类型：在其他元数据中保留表列的原始数据类型。作为默认行为，爬网程序将原始数据类型转换为与 Hive 兼容的类型。
**JDBC 驱动程序类名 - 可选（对于 JDBC 数据存储）**
键入自定义 JDBC 驱动程序类名，以便爬网程序连接到数据来源：
+ Postgres：org.postgresql.Driver
+ MySQL：com.mysql.jdbc.Driver, com.mysql.cj.jdbc.Driver
+ Redshift：com.amazon.redshift.jdbc.Driver, com.amazon.redshift.jdbc42.Driver
+ Oracle：oracle.jdbc.driver.OracleDriver
+ SQL Server：com.microsoft.sqlserver.jdbc.SQLServerDriver
**JDBC 驱动程序 S3 路径 - 可选（对于 JDBC 数据存储）**
选择 `.jar` 文件的现有 Amazon S3 路径。使用自定义 JDBC 驱动程序让爬网程序连接到数据来源时，`.jar` 文件将存储在这里。
**启用数据采样（仅适用于 Amazon DynamoDB、MongoDB、MongoDB Atlas 和 Amazon DocumentDB 数据存储）**
选择是否仅对数据样本进行爬网。如果未选择该选项，则对整个表进行爬网。当表不是高吞吐量表时，扫描所有记录会花费很长时间。
**创建用于查询的表（仅适用于 Delta Lake 数据存储）**
选择要如何创建 Delta Lake 表：
+ 创建原生表：允许与支持直接查询 Delta 事务日志的查询引擎集成。
+ 创建符号链接表：根据指定的配置参数，使用由由分区键分区的清单文件创建符号链接清单文件夹。
**扫描速率 — 可选（仅适用于 DynamoDB 数据存储）**
指定爬网程序使用的 DynamoDB 表读取容量单位的百分比。读取容量单位是一个由 DynamoDB 定义的术语，它是一个数值，用作每秒可对表执行的读取次数的速率限制器。请输入介于 0.1 和 1.5 之间的值。如果未指定，则该值默认为 0.5（对于预置的表）和配置的最大容量的 1/4（对于按需表）。请注意，只应将预置容量模式与 AWS Glue 网络爬取程序结合使用。
对于 DynamoDB 数据存储，请设置预置容量模式来处理表的读写。AWS Glue 网络爬取程序不应与按需容量模式结合使用。
**网络连接：可选（适用于 Amazon S3、Delta、Iceberg、Hudi 和 Catalog 目标数据存储）**
可以包括一个用于此 Amazon S3 目标的网络连接。请注意，每个爬网程序仅限于一个网络连接，因此任何其他 Amazon S3 目标也将使用相同的连接（如果留空，则不使用任何连接）。
有关连接的信息，请参阅 [连接到数据](glue-connections.md)。
**仅对文件子集和样本大小进行采样（仅适用于 Amazon S3 数据存储）**
指定爬取数据集中的示例文件时要网络爬取的每个叶文件夹中的文件数。启用此功能后，爬网程序会随机选择每个叶文件夹中的一些文件进行网络爬取，而不是网络爬取此数据集中的所有文件。
采样爬网程序最适合于先前了解其数据格式并知道其文件夹中的架构不会更改的客户。启用此功能将显著减少爬网程序运行时间。
有效值是介于 1 到 249 之间的整数。如果未指定，则对所有文件进行爬取。
**随后爬网程序运行**
此字段是影响所有 Amazon S3 数据源的全局字段。
+ 爬取所有子文件夹：在后续每次爬取时再次爬取所有文件夹。
+ 仅爬取新子文件夹：仅爬取上次爬取后添加的 Amazon S3 文件夹。如果架构兼容，则新分区将添加到现有表中。有关更多信息，请参阅 [计划用于添加新分区的增量爬取](incremental-crawls.md)。
+ 基于事件爬取：依靠 Amazon S3 事件控制要爬取的文件夹。有关更多信息，请参阅 [使用 Amazon S3 事件通知加速网络爬取](crawler-s3-event-notifications.md)。
**自定义分类器 — 可选**
您可以先定义自定义分类器，然后再定义爬网程序。分类器检查爬网程序是否可以处理给定文件的格式。如果可以处理，分类器将以与该数据格式匹配的 `StructType` 对象的形式创建一个模式。
有关更多信息，请参阅 [定义和管理分类器](add-classifier.md)。
# 步骤 3：配置安全设置
**IAM 角色**
爬网程序将担任此角色。它必须具有类似于 AWS 托管式策略 `AWSGlueServiceRole` 的权限。对于 Amazon S3 和 DynamoDB 源，它还必须具有访问数据存储的权限。如果爬网程序读取使用 AWS Key Management Service（AWS KMS）加密的 Amazon S3 数据，则该角色必须具有 AWS KMS 密钥的解密权限。
对于 Amazon S3 数据存储，附加到角色的其他权限类似于以下内容：
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::bucket/object*"
]
}
]
}
```
对于 Amazon DynamoDB 数据存储，附加到角色的其他权限类似于以下内容：
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeTable",
"dynamodb:Scan"
],
"Resource": [
"arn:aws:dynamodb:*:111122223333:table/table-name*"
]
}
]
}
```
要添加自己的 JDBC 驱动程序，需要添加其他权限。
+ 授予以下作业操作的权限：`CreateJob`、`DeleteJob`、`GetJob`、`GetJobRun`、`StartJobRun`。
+ 授予 Amazon S3 操作的权限：`s3:DeleteObjects`、`s3:GetObject`、`s3:ListBucket`、`s3:PutObject`。
**注意**
如果禁用 Amazon S3 存储桶策略，则不需要使用 `s3:ListBucket`。
+ 在 Amazon S3 策略中授予服务主体访问存储桶/文件夹的权限。
Amazon S3 策略示例：
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListBucket",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/driver-parent-folder/driver.jar",
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
AWS Glue创建以下文件夹（`_crawler` 和 `_glue_job_crawler`，级别与 Amazon S3 存储桶中的 JDBC 驱动程序相同）。例如，如果驱动程序路径为 ``，则将创建以下文件夹（如果这些文件夹尚不存在）：
+
+
（可选）您可以向爬网程序添加安全配置来指定静态加密选项。
有关更多信息，请参阅[步骤 2：为 AWS Glue 创建 IAM 角色](create-an-iam-role.md)和[适用于 AWS Glue 的 Identity and Access Management](security-iam.md)。
**Lake Formation 配置 — 可选**
允许爬网程序使用 Lake Formation 凭证爬取数据存储。
选中 **Use Lake Formation credentials for crawling S3 data source**（使用 Lake Formation 凭证爬取 S3 数据源）将允许爬网程序使用 Lake Formation 凭证爬取数据源。如果数据源属于另一个账户，则必须提供注册的账户 ID。否则，爬网程序将仅爬取与该账户关联的数据源。仅适用于 Amazon S3 和数据目录数据源。
**安全配置 — 可选**
设置包括安全配置。有关更多信息，请参阅下列内容：
+ [加密 AWS Glue 写入的数据](encryption-security-configuration.md)
在爬网程序上设置安全配置后，您可以进行更改，但不能将其移除。要降低爬虫的安全性级别，请在配置中将安全功能显式设置为 `DISABLED`，或者创建一个新的爬网程序。
# 步骤 4：设置输出和计划
**输出配置**
选项包括爬网程序应如何处理检测到的架构更改、数据存储中的已删除对象等等。有关更多信息，请参阅 [自定义爬网程序行为](crawler-configuration.md)。
**爬网程序计划**
您可以按需运行爬网程序，也可以在 AWS Glue 中为爬网程序和作业定义基于时间的计划。这些计划的定义使用类似于 Unix 的 cron 语法。有关更多信息，请参阅 [计划爬网程序](schedule-crawler.md)。
# 第 5 步：审核并创建
查看您配置的爬网程序设置，然后创建爬网程序。
# 计划爬网程序
您可以根据需要或定期计划运行 AWS Glue 爬网程序。当您根据计划设置爬网程序时，您可以指定包含约束，如爬网程序运行的频率、在一周中的那些天运行以及具体时间。您可以以 *cron* 格式创建这些自定义计划。有关更多信息，请参阅 Wikipedia 中的 [cron](http://en.wikipedia.org/wiki/Cron)。
当您为设置爬网程序计划时，您应该考虑 cron 的功能和限制。例如，如果您选择在每月第 31 天运行您的爬网程序，请记住，有些月份没有 31 天。
**Topics**
+ [创建爬网程序计划](create-crawler-schedule.md)
+ [为现有爬网程序创建计划](Update-crawler-schedule.md)
# 创建爬网程序计划
您可以使用 AWS Glue 控制台或 AWS CLI 为爬网程序创建计划。
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台 并打开位于 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\) 的 AWS Glue 控制台。
1. 在导航窗格中选择 **Crawlers (爬网程序)**。
1. 请按照[配置爬网程序](define-crawler.md)部分中的步骤 1-3 操作。
1. 在[步骤 4：设置输出和计划](define-crawler-set-output-and-scheduling.md)中，选择一个**爬网程序计划**以设置运行频率。您可以选择每小时、每天、每周、每月运行爬网程序，也可以使用 cron 表达式定义自定义计划。
cron 表达式是一个表示计划模式的字符串，由 6 个字段组成，用空格隔开：\$1 \$1 \$1 \$1 \$1
例如，要在每天午夜运行任务，cron 表达式为：0 0 \$1 \$1 ? \$1
有关更多信息，请参阅 [Cron 表达式](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html#CronExpressions)。
1. 查看您配置的爬网程序设置，然后创建爬网程序以按计划运行。
------
#### [ AWS CLI ]
```
aws glue create-crawler
--name myCrawler \
--role AWSGlueServiceRole-myCrawler \
--targets '{"S3Targets":[{Path="s3://amzn-s3-demo-bucket/"}]}' \
--schedule cron(15 12 * * ? *)
```
------
有关使用 cron 安排作业和爬网程序的更多信息，请参阅[用于作业和爬网程序的基于时间的计划](monitor-data-warehouse-schedule.md)。
# 为现有爬网程序创建计划
按照以下步骤设置现有爬网程序的定期计划。
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\)。
1. 在导航窗格中选择 **Crawlers (爬网程序)**。
1. 从可用列表中选择要计划的爬网程序。
1. 从**操作菜单**上选择**编辑**。
1. 向下滚动至**步骤 4：设置输出和计划**，然后选择**编辑**。
1. 在**爬网程序计划**下更新您的爬网程序计划。
1. 选择**更新**。
------
#### [ AWS CLI ]
使用以下 CLI 命令更新现有爬网程序配置：
```
aws glue update-crawler-schedule
--crawler-name myCrawler
--schedule cron(15 12 * * ? *)
```
------
# 查看爬网程序结果和详细信息
爬网程序成功运行后，它会在数据目录中创建表定义。在导航窗格中选择 **Tables (表)** 来查看爬网程序在您指定的数据库中创建的表。
您可以按如下方式查看与爬网程序本身相关的信息：
+ AWS Glue 控制台上的 **Crawlers (爬网程序)** 页面显示爬网程序的以下属性：
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/console-crawlers-details.html)
+ 要查看爬网程序的历史记录，请在导航窗格中选择 **Crawlers**（爬网程序）以查看您创建的爬网程序。从可用爬网程序列表中选择一个爬网程序。您可以在 **Crawler runs**（爬网程序运行）选项卡中查看爬网程序属性和爬网程序历史记录。
“Crawler runs”（爬网程序运行）显示每次爬网程序运行时的相关信息，包括 **Start time (UTC)** [开始时间（UTC）]、**End time (UTC)** [结束时间（UTC）]、**Duration**（持续时间）、**Status**（状态）、**DPU hours**（DPU 小时）和 **Table changes**（表格变更）。
“爬网程序运行”选项卡将仅显示自爬网程序历史记录功能启动之日以来发生的爬取操作，并且最长仅保留 12 个月的爬取操作。较早的爬取结果将不会被返回。
+ 要查看其他信息，请在爬网程序详细信息页面中选择一个选项卡。每个选项卡都将显示与爬网程序相关的信息。
+ **Schedule**（计划）：为爬网程序创建的所有计划都将在此处显示。
+ **Data sources**（数据来源）：爬网程序扫描的所有数据来源都将在此处显示。
+ **Classifiers**（分类器）：分配给爬网程序的所有分类器都将在此处显示。
+ **Tags**（标记）：创建并分配给 AWS 资源的所有标记都将在此处显示。
# 爬网程序在数据目录表上设置的参数
这些表属性由 AWS Glue 爬网程序设置。我们希望用户使用 `classification` 和 `compressionType` 属性。其他属性（包括估算表大小）用于内部计算，我们无法保证其准确性或客户使用案例适用性。更改这些参数可能会改变爬网程序的行为，我们不支持此工作流程。
| 属性键 | 属性值 |
| --- | --- |
| UPDATED\$1BY\$1CRAWLER | 执行更新的爬网程序的名称。 |
| connectionName | 用于连接到数据存储的爬网程序在“数据目录”中的连接名称。 |
| recordCount | 根据文件大小和标题估算表中记录的数量。 |
| skip.header.line.count | 跳过行以跳过标题。在被归类为 CSV 的表上设置。 |
| CrawlerSchemaSerializerVersion | 供内部使用 |
| classification | 由爬网程序推断数据格式。更多有关 AWS Glue 爬网程序支持的数据格式的信息，请参阅 [内置分类器](add-classifier.md#classifier-built-in)。 |
| CrawlerSchemaDeserializerVersion | 供内部使用 |
| sizeKey | 已爬取的表中文件的组合大小。 |
| averageRecordSize | 表中行的平均大小（字节）。 |
| compressionType | 对表中的数据使用的压缩类型。更多有关 AWS Glue 爬网程序支持的压缩类型的信息，请参阅 [内置分类器](add-classifier.md#classifier-built-in)。 |
| typeOfData | `file`、`table` 或 `view`。 |
| objectCount | Amazon S3 表路径下的对象数量。 |
这些额外的表属性是由 AWS Glue 爬网程序为 Snowflake 数据存储设置的。
| 属性键 | 属性值 |
| --- | --- |
| aws:RawTableLastAltered | 记录 Snowflake 表上次修改的时间戳。 |
| ViewOriginalText | 查看 SQL 语句。 |
| ViewExpandedText | 查看以 Base64 格式编码的 SQL 语句。 |
| ExternalTable:S3Location | Snowflake 外部表的 Amazon S3 位置。 |
| ExternalTable:FileFormat | Snowflake 外部表的 Amazon S3 文件格式。 |
这些额外的表属性是由 AWS Glue 爬网程序为 Amazon Redshift、Microsoft SQL Server、MySQL、PostgreSQL 和 Oracle 等 JDBC 类型的数据存储设置的。
| 属性键 | 属性值 |
| --- | --- |
| aws:RawType | 当爬网程序将数据存储在数据目录中时，它会将数据类型转换为与 Hive 兼容的类型，这往往会导致有关本机数据类型的信息丢失。爬网程序输出 `aws:RawType` 参数，以提供原生级别的数据类型。 |
| aws:RawColumnComment | 如果注释与数据库中的列相关联，则爬网程序会在目录表中输出相应的注释。注释字符串被截断为 255 个字节。 Microsoft SQL Server 不支持注释。 |
| aws:RawTableComment | 如果注释与数据库中的列相关联，则爬网程序会在目录表中输出相应的注释。注释字符串被截断为 255 个字节。 Microsoft SQL Server 不支持注释。 |
# 自定义爬网程序行为
当您配置 AWS Glue 爬网程序时，有多个选项可用于定义爬网程序的行为。
+ **增量爬取**：您可以将爬网程序配置为运行增量爬取，以便仅向表架构添加新分区。
+ **分区索引**：默认情况下，爬网程序会为 Amazon S3 和 Delta Lake 目标创建分区索引，以便对特定分区提供有效的查找。
+ **使用 Amazon S3 事件加快爬取时间**：您可以配置爬网程序以使用 Amazon S3 事件识别两次网络爬取之间的更改，方法是列出触发事件的子文件夹中的所有文件，而不是列出完整的 Amazon S3 或 Data Catalog 目标。
+ **处理架构更改**：您可以阻止爬网程序对现有架构进行任何架构更改。您可以使用 AWS 管理控制台或 AWS Glue API 来配置爬网程序如何处理某些类型的更改。
+ **多条 Amazon S3 路径的单个架构**：如果数据兼容，则您可以配置爬网程序，为每条 S3 路径创建单个架构。
+ **表位置和分区级别**：通过表级别爬网程序选项，您可以灵活地告诉爬网程序表的位置，以及您希望如何创建分区。
+ **表阈值**：您可以通过指定表阈值来指定爬网程序允许创建的最大表数。
+ **AWS Lake Formation 凭证**：您可以将爬网程序配置为使用 Lake Formation 凭证访问 Amazon S3 数据存储库或 Data Catalog 表，该表包含相同 AWS 账户或不同 AWS 账户中的基础 Amazon S3 位置。
有关使用 AWS Glue 控制台添加爬网程序的更多信息，请参阅[配置爬网程序](define-crawler.md)。
**Topics**
+ [计划用于添加新分区的增量爬取](incremental-crawls.md)
+ [生成分区索引](crawler-configure-partition-indexes.md)
+ [阻止爬网程序更改现有架构](crawler-schema-changes-prevent.md)
+ [为每条 Amazon S3 包含路径创建单个架构](crawler-grouping-policy.md)
+ [指定表位置和分区级别](crawler-table-level.md)
+ [指定允许爬网程序创建的最大表数](crawler-maximum-number-of-tables.md)
+ [将爬网程序配置为使用 Lake Formation 凭证](crawler-lf-integ.md)
+ [使用 Amazon S3 事件通知加速网络爬取](crawler-s3-event-notifications.md)
# 计划用于添加新分区的增量爬取
您可以配置 AWS Glue 爬网程序运行增量爬取，以仅向表架构添加新分区。爬网程序首次运行时，它会执行完全爬取来处理整个数据来源，以记录 AWS Glue Data Catalog 中完整的架构和所有现有分区。
初始完全爬取之后的后续爬取将是增量式的，其中爬网程序仅识别并添加自上次爬取以来引入的新分区。这种方法可以缩短爬取时间，因为爬网程序不再需要每次运行时处理整个数据来源，而是只关注新分区。
**注意**
增量爬取不会检测对现有分区的修改或删除。此配置最适合具有稳定架构的数据来源。如果发生一次性的重大架构变更，建议暂时将爬网程序设置为执行完全爬取以准确捕获新架构，然后再切换回增量爬取模式。
下图显示，启用增量爬取设置后，爬网程序仅检测新添加的文件夹 month=March 并将其添加到目录中。
![\[下图显示已添加三月份的文件。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawlers-s3-folders-new.png)
请按照以下步骤更新爬网程序以执行增量爬取：
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。
1. 在**数据目录**下选择**爬网程序**。
1. 选择要设置为增量爬取的爬网程序。
1. 选择**编辑**。
1. 选择**步骤 2。选择数据来源和分类器**。
1. 选择要增量爬取的数据来源。
1. 选择**编辑**。
1. 在**后续爬网程序运行**下选择**仅爬取新子文件夹**。
1. 选择**更新**。
要为爬网程序创建计划，请参阅[计划爬网程序](schedule-crawler.md)。
------
#### [ AWS CLI ]
```
aws glue update-crawler \
--name myCrawler \
--recrawl-policy RecrawlBehavior=CRAWL_NEW_FOLDERS_ONLY \
--schema-change-policy UpdateBehavior=LOG,DeleteBehavior=LOG
```
------
**注释和限制**
启用此选项后，您无法在编辑爬网程序时更改 Amazon S3 目标数据存储。此选项会影响某些爬网程序配置设置。启用后，它会将爬网程序的更新行为和删除行为强制为 `LOG`。这意味着：
+ 如果发现架构不兼容的对象，爬网程序将不会在 Data Catalog 中添加这些对象，而是将此详细信息作为日志添加到 CloudWatch Logs 中。
+ 它不会更新 Data Catalog 中的已删除对象。
# 生成分区索引
Data Catalog 支持创建分区索引，以提供对特定分区的有效查找。有关更多信息，请参阅 [Creating partition indexes](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html)。默认情况下，AWS Glue 爬网程序会为 Amazon S3 和 Delta Lake 目标创建分区索引。
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。
1. 在**数据目录**下选择**爬网程序**。
1. 定义爬网程序时，在**设置输出和调度**页面中的**高级选项**下，**自动创建分区索引**选项默认处于启用状态。
要禁用此选项，可以在控制台中取消选择**自动创建分区索引**复选框。
1. 完成爬网程序配置并选择**创建爬网程序**。
------
#### [ AWS CLI ]
您也可以使用 AWS CLI 禁用此选项，在 `configuration` 参数中设置 `CreatePartitionIndex `。默认值为 true。
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "CreatePartitionIndex": false }'
```
------
## 分区索引的使用说明
+ 默认情况下，由爬网程序创建的表没有变量 `partition_filtering.enabled`。有关更多信息，请参阅 [AWS Glue partition indexing and filtering](https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index)。
+ 不支持为加密分区创建分区索引。
# 阻止爬网程序更改现有架构
您可以阻止 AWS Glue 爬网程序在运行时对 Data Catalog 进行任何架构更改。默认情况下，爬网程序会更新 Data Catalog 中的架构，使其与正在爬取的数据来源相匹配。但是，在某些情况下，您可能需要阻止爬网程序修改现有架构，尤其是在您已经转换或清理数据并且不希望原始架构覆盖更改的情况下。
按照以下步骤将您的爬网程序配置为不覆盖表定义中的现有架构。
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。
1. 在**数据目录**下选择**爬网程序**。
1. 从列表中选择一个爬网程序，然后选择**编辑**。
1. 选择**步骤 4，设置输出和计划**。
1. 在**高级选项**下，选择**仅添加新列**或**忽略更改，不更新 Data Catalog 中的表**。
1. 您还可以将配置选项设置为**使用表中的元数据更新所有新的和现有的分区**。这会将分区架构设置为从表继承。
1. 选择**更新**。
------
#### [ AWS CLI ]
以下示例说明如何将爬网程序配置为不更改现有架构，仅添加新列：
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "CrawlerOutput": {"Tables": {"AddOrUpdateBehavior": "MergeNewColumns"}}}'
```
以下示例说明如何将爬网程序配置为不更改现有架构，且不添加新列：
```
aws glue update-crawler \
--name myCrawler \
--schema-change-policy UpdateBehavior=LOG \
--configuration '{"Version": 1.0, "CrawlerOutput": {"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" }}}'
```
------
#### [ API ]
如果您不希望在爬网程序运行时更改表架构，请将架构更改策略设置为 `LOG`。
当您使用 API 配置爬网程序时，请设置以下参数：
+ 将 `SchemaChangePolicy` 结构中的 `UpdateBehavior` 字段设置为 `LOG`。
+ 使用爬网程序 API 中的以下 JSON 对象的字符串表示形式设置 `Configuration` 字段；例如：
```
{
"Version": 1.0,
"CrawlerOutput": {
"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" }
}
}
```
------
# 为每条 Amazon S3 包含路径创建单个架构
默认情况下，当爬网程序为 Amazon S3 中存储的数据定义表时，它会同时考虑数据兼容性和架构相似性。它考虑的数据兼容性因素包括数据是否具有相同的格式（例如，JSON），相同的压缩类型（例如，GZIP），Amazon S3 路径的结构以及其他数据属性。架构相似性衡量单独 Amazon S3 对象的架构的相似程度。
为帮助说明此选项，假设您使用包含路径 `s3://amzn-s3-demo-bucket/table1/` 定义了一个爬网程序。当该爬网程序运行时，它会找到两个具有以下特征的 JSON 文件：
+ **文件 1** – `S3://amzn-s3-demo-bucket/table1/year=2017/data1.json`
+ *文件内容* – `{“A”: 1, “B”: 2}`
+ *架构* – `A:int, B:int`
+ **文件 2** – `S3://amzn-s3-demo-bucket/table1/year=2018/data2.json`
+ *文件内容* – `{“C”: 3, “D”: 4}`
+ *架构* – `C: int, D: int`
默认情况下，该爬网程序会创建两个名为 `year_2017` 和 `year_2018` 的表，因为架构不够相似。但是，如果选项 **Create a single schema for each S3 path (为每个 S3 路径创建单个架构)** 处于选中状态，并且数据是兼容的，则爬网程序会创建一个表。该表具有架构 `A:int,B:int,C:int,D:int` 和 `partitionKey` `year:string`。
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。
1. 在**数据目录**下选择**爬网程序**。
1. 配置新爬网程序时，在**输出和计划**下，选择高级选项下的**为每条 S3 路径创建单个架构**选项。
------
#### [ AWS CLI ]
您可以在可能的情况下将 `CombineCompatibleSchemas` 的爬网程序配置为公用表定义。使用此选项，爬网程序仍会考虑数据兼容性，但在评估指定包含路径中的 Amazon S3 对象时会忽略特定架构的相似性。
当您使用 AWS CLI 配置爬网程序时，请设置以下配置选项：
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "Grouping": {"TableGroupingPolicy": "CombineCompatibleSchemas" }}'
```
------
#### [ API ]
当您使用 API 配置爬网程序时，请设置以下配置选项：
使用爬网程序 API 中的以下 JSON 对象的字符串表示形式设置 `Configuration` 字段；例如：
```
{
"Version": 1.0,
"Grouping": {
"TableGroupingPolicy": "CombineCompatibleSchemas" }
}
```
------
# 指定表位置和分区级别
默认情况下，当爬网程序为 Amazon S3 中存储的数据定义表时，爬网程序会尝试将架构合并在一起并创建顶级表（`year=2019`）。在某些情况下，您可能希望爬网程序为文件夹 `month=Jan` 创建一个表，但由于同级文件夹（`month=Mar`）已合并到同一个表中，因此爬网程序会创建一个分区。
通过表级别爬网程序选项，您可以灵活地告诉爬网程序表的位置，以及您希望如何创建分区。当您指定 **Table level (表级别)** 时，则会从 Amazon S3 存储桶中以该绝对级别创建表。
![\[将表级别指定为级别 2 的爬网程序分组。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawler-table-level1.jpg)
当在控制台上配置爬网程序时，您可以为 **Table level (表级别)** 爬网程序选项指定一个值。该值必须是指示表位置（数据集中的绝对级别）的正整数。顶级文件夹的级别为 1。例如，对于路径 `mydataset/year/month/day/hour`，如果级别设置为 3，则在位置 `mydataset/year/month` 处创建表。
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。
1. 在**数据目录**下选择**爬网程序**。
1. 配置爬网程序时，在**输出和计划**下，选择**高级选项**下的**表级别**。
![\[在爬网程序配置中指定表级别。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawler-configuration-console.png)
------
#### [ AWS CLI ]
使用 AWS CLI 配置爬网程序时，请按示例代码所示设置 `configuration` 参数：
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "Grouping": { "TableLevelConfiguration": 2 }}'
```
------
#### [ API ]
使用 API 配置爬网程序时，请使用以下 JSON 对象的字符串表示形式设置 `Configuration` 字段；例如：
```
configuration = jsonencode(
{
"Version": 1.0,
"Grouping": {
TableLevelConfiguration = 2
}
})
```
------
#### [ CloudFormation ]
在本例中，您在 CloudFormation 模板的控制台中设置了可用的**表级别**选项：
```
"Configuration": "{
\"Version\":1.0,
\"Grouping\":{\"TableLevelConfiguration\":2}
}"
```
------
# 指定允许爬网程序创建的最大表数
您可以选择指定允许爬网程序创建的最大表数，方法是通过 AWS Glue 控制台或 AWS CLI 指定 `TableThreshold`。如果爬网程序在其爬取过程中检测到的表数大于此输入值，则爬取失败且不会向 Data Catalog 写入任何数据。
当爬网程序检测和创建的表数比预期表数要大得多时，此参数非常有用。这可能有多种原因，例如：
+ 使用 AWS Glue 作业填充 Amazon S3 位置时，您最终可能会得到与文件夹相同级别的空文件。在这种情况下，当您在此 Amazon S3 位置运行爬网程序时，由于文件和文件夹位于同一级别，爬网程序会创建多个表。
+ 如果没有配置 `"TableGroupingPolicy": "CombineCompatibleSchemas"`，您最终得到的表数可能比预期数量多。
您可以将 `TableThreshold` 指定为一个大于 0 的整数值。该值根据每个爬网程序进行配置。也就是说，每次爬取都会考虑该值。例如：爬网程序的 `TableThreshold` 值设置为 5。每次爬取时，AWS Glue 会将检测到的表数与此表阈值（5）进行比较。如果检测到的表数小于 5，AWS Glue 将表写入 Data Catalog；否则，爬取失败，将不会写入 Data Catalog。
------
#### [ AWS 管理控制台 ]
**使用 AWS 管理控制台 设置 `TableThreshold`：**
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。
1. 配置爬网程序时，在**输出和计划**中，将**最大表阈值**设置为爬网程序允许生成的表数。
![\[AWS 控制台的“Output and scheduling”（输出和计划）部分显示最大表阈值参数。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawler-max-tables.png)
------
#### [ AWS CLI ]
使用 AWS CLI 设置 `TableThreshold`：
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "CrawlerOutput": {"Tables": { "TableThreshold": 5 }}}'
```
------
#### [ API ]
使用 API 设置 `TableThreshold`：
```
"{"Version":1.0,
"CrawlerOutput":
{"Tables":{"AddOrUpdateBehavior":"MergeNewColumns",
"TableThreshold":5}}}";
```
------
记录错误消息以帮助您识别表路径和清理数据。爬网程序因表数大于提供的表阈值而失败时您账户中的日志示例：
```
Table Threshold value = 28, Tables detected - 29
```
在 CloudWatch 中，我们将检测到的所有表位置记录为 INFO 消息。将错误记录为失败原因。
```
ERROR com.amazonaws.services.glue.customerLogs.CustomerLogService - CustomerLogService received CustomerFacingException with message
The number of tables detected by crawler: 29 is greater than the table threshold value provided: 28. Failing crawler without writing to Data Catalog.
com.amazonaws.services.glue.exceptions.CustomerFacingInternalException: The number of tables detected by crawler: 29 is greater than the table threshold value provided: 28.
Failing crawler without writing to Data Catalog.
```
# 将爬网程序配置为使用 Lake Formation 凭证
您可以将爬网程序配置为使用 AWS Lake Formation 凭证访问 Amazon S3 数据存储库或 Data Catalog 表的证书，该表包含相同 AWS 账户 或不同 AWS 账户 中的基础 Amazon S3 位置。如果爬网程序与 Data Catalog 表位于同一账户中，则可以将现有 Data Catalog 表配置为爬网程序的目标。使用 Data Catalog 表作为爬网程序的目标时，目前只允许具有单个目录表的单个目录目标。
**注意**
将 Data Catalog 表定义为爬网程序目标时，请确保 Data Catalog 表的基础位置是 Amazon S3 位置。使用 Lake Formation 凭证的爬网程序仅支持具有基础 Amazon S3 位置的 Data Catalog 目标。
## 爬网程序与注册的 Amazon S3 位置或 Data Catalog 表位于同一账户（账户内爬取）时所需的设置
要允许爬网程序使用 Lake Formation 凭证访问数据存储或 Data Catalog 表，您需要向 Lake Formation 注册数据位置。此外，爬网程序的 IAM 角色必须有从 Amazon S3 桶的注册目标读取数据的权限。
您可以使用 AWS 管理控制台 或 AWS Command Line Interface（AWS CLI）完成以下配置步骤。
------
#### [ AWS 管理控制台 ]
1. 在配置爬网程序以访问爬网程序源之前，向 Lake Formation 注册数据存储或 Data Catalog 的数据位置。在 Lake Formation 控制台（[https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)）中，将 Amazon S3 位置注册为定义爬网程序的 AWS 账户 中数据湖的根位置。有关更多信息，请参阅 [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html)（注册 Amazon S3 位置）。
1. 向用于爬网程序运行的 IAM 角色授予 **Data location**（数据位置）权限，以便爬网程序可以从 Lake Formation 中的目标读取数据。有关更多信息，请参阅 [Granting data location permissions (same account)](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-location-permissions-local.html)（授予数据位置权限（同一账户））。
1. 授予爬网程序角色访问数据库的权限（`Create`），该数据库被指定为输出数据库。有关更多信息，请参阅 [Granting database permissions using the Lake Formation console and the named resource method](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-database-permissions.html)（使用 Lake Formation 控制台和指定的资源方法授予数据库权限）。
1. 在 IAM 控制台（[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)）中，为爬网程序创建 IAM 角色。将 `lakeformation:GetDataAccess` 策略添加到该角色。
1. 在 AWS Glue 控制台（[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)）中配置爬网程序时，选择选项 **Use Lake Formation credentials for crawling Amazon S3 data source**（使用 Lake Formation 凭证爬取 Amazon S3 数据来源）。
**注意**
accountId 字段对于账户内爬取是可选的。
------
#### [ AWS CLI ]
```
aws glue --profile demo create-crawler --debug --cli-input-json '{
"Name": "prod-test-crawler",
"Role": "arn:aws:iam::111122223333:role/service-role/AWSGlueServiceRole-prod-test-run-role",
"DatabaseName": "prod-run-db",
"Description": "",
"Targets": {
"S3Targets":[
{
"Path": "s3://amzn-s3-demo-bucket"
}
]
},
"SchemaChangePolicy": {
"UpdateBehavior": "LOG",
"DeleteBehavior": "LOG"
},
"RecrawlPolicy": {
"RecrawlBehavior": "CRAWL_EVERYTHING"
},
"LineageConfiguration": {
"CrawlerLineageSettings": "DISABLE"
},
"LakeFormationConfiguration": {
"UseLakeFormationCredentials": true,
"AccountId": "111122223333"
},
"Configuration": {
"Version": 1.0,
"CrawlerOutput": {
"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" },
"Tables": {"AddOrUpdateBehavior": "MergeNewColumns" }
},
"Grouping": { "TableGroupingPolicy": "CombineCompatibleSchemas" }
},
"CrawlerSecurityConfiguration": "",
"Tags": {
"KeyName": ""
}
}'
```
------
# 爬网程序与注册的 Amazon S3 位置位于不同账户（跨账户爬取）时所需的设置
要允许爬网程序使用 Lake Formation 凭证访问不同账户中的数据存储，您必须先向 Lake Formation 注册 Amazon S3 数据位置。然后，通过执行以下步骤向爬网程序的账户授予数据位置权限。
您可以使用 AWS 管理控制台 或 AWS CLI 完成以下步骤。
------
#### [ AWS 管理控制台 ]
1. 在注册 Amazon S3 位置的账户（账户 B）中：
1. 向 Lake Formation 注册 Amazon S3 路径。有关更多信息，请参阅[注册 Amazon S3 位置](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html)。
1. 向将运行爬网程序的账户（账户 A）授予 **Data location**（数据位置）权限。有关更多信息，请参阅[授予数据位置权限](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-location-permissions-local.html)。
1. 在 Lake Formation 中创建一个空数据库，将基础位置作为目标 Amazon S3 位置。有关更多信息，请参阅[创建数据库](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-database.html)。
1. 授予账户 A（将运行爬网程序的账户）访问您在上一步中创建的数据库的权限。有关更多信息，请参阅[授予数据库权限](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-database-permissions.html)。
1. 在创建并将运行爬网程序的账户（账户 A）中：
1. 使用 AWS RAM 控制台，接受从外部账户（账户 B）共享的数据库。有关更多信息，请参阅 [Accepting a resource share invitation from AWS Resource Access Manager](https://docs.aws.amazon.com/lake-formation/latest/dg/accepting-ram-invite.html)（接受来自 RAMlong 的资源共享邀请）。
1. 为爬网程序创建 IAM 角色。将 `lakeformation:GetDataAccess` 策略添加到该角色。
1. 在 Lake Formation 控制台（[https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)）中，授予用于爬网程序运行的 IAM 角色目标 Amazon S3 位置上的 **Data location**（数据位置）权限，以使爬网程序能够从 Lake Formation 中的目标读取数据。有关更多信息，请参阅[授予数据位置权限](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-location-permissions-local.html)。
1. 在共享数据库上创建资源链接。有关更多信息，请参阅[创建资源链接](https://docs.aws.amazon.com/lake-formation/latest/dg/create-resource-link-database.html)。
1. 授予爬网程序角色对共享数据库和（`Describe`）资源链接的访问权限（`Create`）。资源链接在爬网程序的输出中指定。
1. 在 AWS Glue 控制台（[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)）中配置爬网程序时，选择选项 **Use Lake Formation credentials for crawling Amazon S3 data source**（使用 Lake Formation 凭证爬取 Amazon S3 数据来源）。
对于跨账户爬取，请指定向 Lake Formation 注册的目标 Amazon S3 位置的 AWS 账户 ID。对于账户内爬取，accountId 字段是可选的。
![\[IAM role selection and Lake Formation configuration options for AWS Glue 爬网程序 security settings.\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/cross-account-crawler.png)
------
#### [ AWS CLI ]
```
aws glue --profile demo create-crawler --debug --cli-input-json '{
"Name": "prod-test-crawler",
"Role": "arn:aws:iam::111122223333:role/service-role/AWSGlueServiceRole-prod-test-run-role",
"DatabaseName": "prod-run-db",
"Description": "",
"Targets": {
"S3Targets":[
{
"Path": "s3://amzn-s3-demo-bucket"
}
]
},
"SchemaChangePolicy": {
"UpdateBehavior": "LOG",
"DeleteBehavior": "LOG"
},
"RecrawlPolicy": {
"RecrawlBehavior": "CRAWL_EVERYTHING"
},
"LineageConfiguration": {
"CrawlerLineageSettings": "DISABLE"
},
"LakeFormationConfiguration": {
"UseLakeFormationCredentials": true,
"AccountId": "111111111111"
},
"Configuration": {
"Version": 1.0,
"CrawlerOutput": {
"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" },
"Tables": {"AddOrUpdateBehavior": "MergeNewColumns" }
},
"Grouping": { "TableGroupingPolicy": "CombineCompatibleSchemas" }
},
"CrawlerSecurityConfiguration": "",
"Tags": {
"KeyName": ""
}
}'
```
------
**注意**
只有 Amazon S3 和 Data Catalog 目标支持使用 Lake Formation 凭证的爬网程序。
对于使用 Lake Formation 凭证售卖的目标，基础 Amazon S3 位置必须属于同一个桶。例如，只要所有目标位置都在同一个存储桶 (amzn-s3-demo-bucket1) 下，客户就可以使用多个目标（s3://amzn-s3-demo-bucket1/folder1、s3://amzn-s3-demo-bucket1/folder2）。不允许指定不同的存储桶（s3://amzn-s3-demo-bucket1/folder1、s3://amzn-s3-demo-bucket2/folder2）。
目前，对于 Data Catalog 目标爬网程序，只允许具有单个目录表的单个目录目标。
# 使用 Amazon S3 事件通知加速网络爬取
您可以将爬网程序配置为使用 Amazon S3 事件来查找任何更改，而不是列出 Amazon S3 或 Data Catalog 目标中的对象。此功能使用 Amazon S3 事件，通过列出触发事件的子文件夹中的所有文件，而不是列出完整的 Amazon S3 或 Data Catalog 目标，来识别两次网络爬取之间的更改，从而缩短了重新爬网时间。
第一次网络爬取会列出目标中的所有 Amazon S3 对象。第一次成功爬取之后，您可以选择手动重新爬取或按设定计划重新爬取。爬网程序只会列出这些事件中的对象，而不会列出所有对象。
当目标为 Data Catalog 表时，爬网程序会利用更改（例如，表中的额外分区）更新 Data Catalog 中的现有表。
迁移到基于 Amazon S3 事件的爬网程序的优点包括：
+ 不需要列出目标中的所有对象，而是在添加或删除对象的位置列出特定文件夹，从而重新爬网更快。
+ 在添加或删除对象的位置列出特定文件夹，从而降低总体网络爬取成本。
Amazon S3 事件网络爬取基于爬网程序调度，从 SQS 队列中使用 Amazon S3 事件来运行。如果队列中没有事件，则无需支付费用。Amazon S3 事件可以配置为直接进入 SQS 队列，或者在多个用户需要相同事件的情况下，也可以配置为 SNS 和 SQS 的组合。有关更多信息，请参阅 [为 Amazon S3 事件通知设置账户](#crawler-s3-event-notifications-setup)。
在事件模式下创建和配置爬网程序之后，第一次网络爬取将在列表模式下通过执行 Amazon S3 或 Data Catalog 目标的完整列表来运行。第一次成功网络爬取后将使用 Amazon S3 事件，以下日志可确认网络爬取的运行：“网络爬取正在使用 Amazon S3 事件来运行。”
创建 Amazon S3 事件网络爬取并更新可能影响网络爬取的爬网程序属性后，网络爬取将在列表模式下运行，并添加以下日志：“网络爬取未在 S3 事件模式下运行”。
**注意**
每次爬取使用的最大消息数为 10 万条。
## 注意事项和限制
在配置爬网程序使用 Amazon S3 事件通知来查找任何更改时，要考虑以下注意事项和限制事项。
+ **已删除分区的重要行为**
将 Amazon S3 事件爬网程序与 Data Catalog 表配合使用时：
+ 如果使用 `DeletePartition` API 调用删除分区，则还须删除该分区下的所有 S3 对象，并在配置 S3 事件通知时选择**所有对象删除事件**。如果未配置删除事件，爬网程序会在下次运行时重新创建已删除分区。
+ 无论是 Amazon S3 还是 Data Catalog 目标，爬网程序仅支持单个目标。
+ 不支持私有 VPC 上的 SQS。
+ 不支持 Amazon S3 采样。
+ 爬网程序目标应为 Amazon S3 目标的文件夹，或者 Data Catalog 目标的一个或多个 AWS Glue Data Catalog 表。
+ 不支持“所有”路径通配符：s3://%
+ 对于 Data Catalog 目标，所有目录表都应指向 Amazon S3 事件模式的同一 Amazon S3 存储桶。
+ 对于 Data Catalog 目标，目录表不应指向 Delta Lake 格式的 Amazon S3 位置（包含 \$1symlink 文件夹或检查目录表的 `InputFormat`）。
**Topics**
+ [注意事项和限制](#s3event-crawler-limitations)
+ [为 Amazon S3 事件通知设置账户](#crawler-s3-event-notifications-setup)
+ [针对 Amazon S3 目标设置 Amazon S3 事件通知的爬网程序](crawler-s3-event-notifications-setup-console-s3-target.md)
+ [为 Data Catalog 表设置 Amazon S3 事件通知的爬网程序](crawler-s3-event-notifications-setup-console-catalog-target.md)
## 为 Amazon S3 事件通知设置账户
完成以下设置任务。请注意，括号中的值引用了脚本中的可配置设置。
1. 您需要为自己的 Amazon S3 存储桶设置事件通知。
有关更多信息，请参阅 [Amazon S3 事件通知](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html)。
1. 要使用基于 Amazon S3 事件的爬网程序，您应该在 Amazon S3 存储桶上启用事件通知，然后使用从与 S3 目标相同的前缀中筛选的事件，并存储在 SQS 中。您可以按照[演练：为存储桶配置通知](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ways-to-add-notification-config-to-bucket.html)中的步骤通过控制台设置 SQS 和事件通知。
1. 将以下 SQS 策略添加到爬网程序使用的角色。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sqs:DeleteMessage",
"sqs:GetQueueUrl",
"sqs:ListDeadLetterSourceQueues",
"sqs:ReceiveMessage",
"sqs:GetQueueAttributes",
"sqs:ListQueueTags",
"sqs:SetQueueAttributes",
"sqs:PurgeQueue"
],
"Resource": "arn:aws:sqs:us-east-1:111122223333:cfn-sqs-queue"
}
]
}
```
------
# 针对 Amazon S3 目标设置 Amazon S3 事件通知的爬网程序
按照以下步骤使用 AWS 管理控制台或 AWS CLI 为 Amazon S3 目标设置 Amazon S3 事件通知的爬网程序。
------
#### [ AWS 管理控制台 ]
1. 登录 AWS 管理控制台，打开 GuardDuty 控制台：[https://console.aws.amazon.com/guardduty/](https://console.aws.amazon.com/guardduty/)。
1. 设置爬网程序属性。有关更多信息，请参阅[在 AWS Glue 控制台上设置爬网程序配置选项](https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html#crawler-configure-changes-console)。
1. 在**数据来源配置**部分中，系统将询问*您的数据是否已映射到 AWS Glue 表？*
默认情况下已选择 **Not yet**（尚未）。请将其保留为默认值，这是因为您使用的是 Amazon S3 数据来源，而该数据尚未映射到 AWS Glue 表。
1. 在 **Data sources**（数据来源）部分中，选择 **Add a data source**（添加数据来源）。
![\[Data source configuration interface with options to select or add data sources for crawling.\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawler-s3-event-console1.png)
1. 在 **Add data source**（添加数据来源）模态中，配置 Amazon S3 数据来源：
+ **Data source**（数据来源）：默认选择 Amazon S3。
+ **Network connection**（网络连接）（可选）：选择 **Add new connection**（添加新连接）。
+ **Location of Amazon S3 data**（Amazon S3 数据位置）：默认选择 **In this account**（此账户中）。
+ **Amazon S3 path**（Amazon S3 路径）：指定在其中爬取文件夹和文件的 Amazon S3 路径。
+ **Subsequent crawler runs**（后续爬网程序运行）：选择 **Crawl based on events**（基于事件爬取）以对爬网程序使用 Amazon S3 事件通知。
+ **Include SQS ARN**（包含 SQS ARN）：指定数据存储参数，包括有效的 SQS ARN。（例如，`arn:aws:sqs:region:account:sqs`）。
+ **Include dead-letter SQS ARN**（包含死信 SQS ARN）（可选）：指定有效的 Amazon 死信 SQS ARN。（例如，`arn:aws:sqs:region:account:deadLetterQueue`）。
+ 选择 **Add an Amazon S3 data source**（添加 Amazon S3 数据来源）。
![\[Add data source dialog for S3, showing options for network connection and crawl settings.\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawler-s3-event-console2.png)
------
#### [ AWS CLI ]
以下是 Amazon S3 AWS CLI 调用示例，用于配置爬网程序以使用事件通知来爬取 Amazon S3 目标存储桶。
```
Create Crawler:
aws glue update-crawler \
--name myCrawler \
--recrawl-policy RecrawlBehavior=CRAWL_EVENT_MODE \
--schema-change-policy UpdateBehavior=UPDATE_IN_DATABASE,DeleteBehavior=LOG
--targets '{"S3Targets":[{"Path":"s3://amzn-s3-demo-bucket/", "EventQueueArn": "arn:aws:sqs:us-east-1:012345678910:MyQueue"}]}'
```
------
# 为 Data Catalog 表设置 Amazon S3 事件通知的爬网程序
当您有 Data Catalog 表时，请使用 AWS Glue 控制台设置 Amazon S3 事件通知的爬网程序：
1. 设置爬网程序属性。有关更多信息，请参阅[在 AWS Glue 控制台上设置爬网程序配置选项](https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html#crawler-configure-changes-console)。
1. 在**数据来源配置**部分中，系统将询问*您的数据是否已映射到 AWS Glue 表？*
选择 **Yes**（是），从 Data Catalog 中选择现有表作为数据来源。
1. 在 **Glue tables**（Glue 表）部分中，选择 **Add tables**（添加表）。
![\[Data source configuration interface with options to select existing Glue tables or add new ones.\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawler-s3-event-console1-cat.png)
1. 在 **Add table**（添加表）模式中，配置数据库和表：
+ **Network connection**（网络连接）（可选）：选择 **Add new connection**（添加新连接）。
+ **Database**（数据库）：在 Data Catalog 中选择数据库。
+ **Tables**（表）：在 Data Catalog 中选择该数据库中的一个或多个表。
+ **Subsequent crawler runs**（后续爬网程序运行）：选择 **Crawl based on events**（基于事件爬取）以对爬网程序使用 Amazon S3 事件通知。
+ **Include SQS ARN**（包含 SQS ARN）：指定数据存储参数，包括有效的 SQS ARN。（例如，`arn:aws:sqs:region:account:sqs`）。
+ **Include dead-letter SQS ARN**（包含死信 SQS ARN）（可选）：指定有效的 Amazon 死信 SQS ARN。（例如，`arn:aws:sqs:region:account:deadLetterQueue`）。
+ 选择**确认**。
![\[Add Glue tables dialog with network, database, tables, and crawler options.\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawler-s3-event-console2-cat.png)
# 教程：添加 AWS Glue 爬网程序
对于此 AWS Glue 场景，需要您分析主要航空公司的抵达数据，从而计算出发机场每月的受欢迎程度。您拥有以 CSV 格式存储在 Amazon S3 中的 2016 年的航班数据。在转换和分析数据之前，请您先将其元数据编录在 AWS Glue Data Catalog 中。
在本教程中，让我们添加一个能够根据 Amazon S3 中的这些飞行日志推断元数据，并且能在您的数据目录中创建表的爬网程序。
**Topics**
+ [先决条件](#tutorial-add-crawler-prerequisites)
+ [步骤 1：添加爬网程序](#tutorial-add-crawler-step1)
+ [步骤 2：运行爬网程序](#tutorial-add-crawler-step2)
+ [步骤 3：查看 AWS Glue Data Catalog 对象](#tutorial-add-crawler-step3)
## 先决条件
本教程假定您拥有 AWS 账户并具有对 AWS Glue 的访问权限。
## 步骤 1：添加爬网程序
使用以下步骤配置并运行能够从 Amazon S3 存储的 CSV 文件中提取元数据的爬网程序。
**要创建能够读取 Amazon S3 存储的文件的爬网程序**
1. 在 AWS Glue 服务控制台的左侧菜单，选择 **Crawlers (爬网程序)**。
1. 在“爬网程序”页面上，选择**创建爬网程序**。这将打开一系列页面，提示您输入爬网程序详细信息。
![\[屏幕截图显示的是爬网程序页面。在这里，您可以创建爬网程序或者编辑、复制、删除、查看现有的爬网程序。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/crawlers-create_crawler.png)
1. 在 Crawler name (爬网程序名称) 字段中，输入 **Flights Data Crawler**，然后选择 **Next (下一步)**。
爬网程序会调用分类器来推断您的数据架构。预设情况下，本教程使用 CSV 的内置分类器。
1. 对于爬网程序源类型，选择 **Data stores (数据存储)**，然后选择 **Next (下一步)**。
1. 现在，让我们将爬网程序指向您的数据。在 **Add a data store (添加数据存储)** 页面上，选择 Amazon S3 data store (Amazon S3 数据存储)。本教程不使用连接，因此请将 **Connection (连接)** 字段留空（如果可见）。
对于 **Crawl data in (对以下位置的数据进行爬网)** 选项，选择 **Specified path in another account (另一个账户中的指定路径)**。然后，对于 **Include path (包含路径)**，输入爬网程序可以找到航班数据的路径，即 **s3://crawler-public-us-east-1/flight/2016/csv**。输入路径后，此字段的标题将更改为 **Include path (包含路径)**。选择**下一步**。
1. 您可以使用单个爬网程序对多个数据存储进行爬网。但是，在本教程中，我们只使用单个数据存储，因此选择 **No (否)**，然后选择 **Next (下一步)**。
1. 爬网程序需要权限才能访问数据存储并在 AWS Glue Data Catalog 中创建对象。要配置这些权限，请选择 **Create an IAM role (创建 IAM 角色)**。IAM 角色名称以 `AWSGlueServiceRole-` 开头，另外在字段中，请您输入角色名称的最后一部分。输入 **CrawlerTutorial**，然后选择 **Next (下一步)**。
**注意**
要创建 IAM 角色，您的亚马逊云科技用户必须具有对 `CreateRole`、`CreatePolicy` 和 `AttachRolePolicy` 的访问权限。
向导将创建名为 `AWSGlueServiceRole-CrawlerTutorial` 的 IAM 角色，并为此角色附上 AWS 托管式策略 `AWSGlueServiceRole`，然后添加允许对 Amazon S3 位置 `s3://crawler-public-us-east-1/flight/2016/csv` 进行读取访问内联策略。
1. 创建爬网程序计划。对于 **Frequency (频率)**，选择 **Run on demand (按需运行)**，然后选择 **Next (下一步)**。
1. 爬网程序在数据目录中创建表。数据目录中的数据库包含元数据表。首先，选择 **Add database (添加数据库)** 来创建数据库。在弹出窗口中，输入 **test-flights-db** 作为数据库名称，然后选择 **Create (创建)**。
接下来，输入 **flights** 作为**添加到表中的前缀**。使用其余选项的原定设置值，然后选择 **Next (下一步)**。
1. 验证您在 **Add crawler (添加爬网程序)** 向导中所做的选择。如果看到任何错误，您可以选择 **Back (返回)**，从而返回到之前的页面进行更改。
查看信息后，选择 **Finish (完成)**，结束创建爬网程序。
## 步骤 2：运行爬网程序
创建爬网程序后，向导会将您引导至爬网程序视图页面。由于您使用按需计划创建爬网程序，因此将为您提供运行爬网程序的选项。
**要运行爬网程序**
1. 此页面顶部附近的横幅会告知您爬网程序已完成创建，并询问您是否要立即运行。选择 **Run it now? (现在运行它？)** 来运行爬网程序。
该横幅更改为显示爬网程序的“尝试运行”和“正在运行”消息。爬完程序开始运行后，横幅消失，爬网程序显示更新，以显示启动状态。一分钟后，您可以单击 Refresh (刷新) 图标来更新表中显示的爬网程序的状态。
1. 爬网程序完成后，将出现一条描述爬网程序所做更改的新横幅。您可以选择 **test-flights-db** 链接来查看数据目录对象。
## 步骤 3：查看 AWS Glue Data Catalog 对象
爬网程序在源位置读取数据并在数据目录中创建表。表是代表您的数据及其架构的元数据定义。数据目录中的表不包含数据。相反，您可以使用这些表作为任务定义中的源或目标。
**要查看爬网程序创建的数据目录对象**
1. 在左侧导航窗格中的 **Data catalog (数据目录)** 下方，选择 **Databases (数据库)**。在这里，您可以查看爬网程序创建的 `flights-db` 数据库。
1. 在左侧导航窗格的 **Data catalog (数据目录)** 以及 **Databases (数据库)** 下方，选择 **Tables (表)**。在这里，您可以查看爬网程序创建的 `flightscsv` 表。如果您选择表名称，则可以查看表设置、参数和属性。在此视图中向下滚动，您可以查看关于表的列和数据类型信息的架构。
1. 如果在表视图页面上选择 **View partitions (查看分区)**，您可以看到为数据创建的分区。第一列将作为分区键。
# 手动定义元数据
AWS Glue Data Catalog 是一个中央存储库，用于存储有关您的数据来源和数据集的元数据。虽然爬网程序可以自动爬取和填充支持的数据来源的元数据，但在某些情况下，您可能需要在 Data Catalog 中手动定义元数据：
+ 不支持的数据格式 – 如果您的数据来源不受爬网程序支持，则需要在 Data Catalog 中手动定义这些数据来源的元数据。
+ 自定义元数据要求 – AWS Glue 爬网程序 根据预定义的规则和约定推断元数据。如果您有 AWS Glue 爬网程序 推断元数据未涵盖的特定元数据要求，则可以手动定义元数据以满足您的需求
+ 数据治理和标准化 – 在某些情况下，出于数据治理、合规性或安全原因，您可能需要对元数据定义拥有更多控制。通过手动定义元数据，您可以确保元数据符合组织的标准和政策。
+ 用于未来数据摄取的占位符 – 如果您的数据来源无法立即使用或无法立即访问，则可以创建空架构表作为占位符。数据来源可用后，您可以使用实际数据填充表，同时保持预定义的结构。
要手动定义元数据，您可以使用 AWS Glue 控制台、Lake Formation 控制台、AWS Glue API 或 AWS Command Line Interface（AWS CLI）。您可以创建数据库、表和分区，并指定元数据属性，例如列名称、数据类型、描述和其他属性。
# 创建数据库
数据库用于组织 AWS Glue 中的元数据表。在 AWS Glue Data Catalog 中定义表时，您将其添加到数据库。表只能位于一个数据库中。
您的数据库可以包含定义来自很多不同数据存储的数据的表。此数据可以包括 Amazon Simple Storage Service（Amazon S3）中的对象和 Amazon Relational Database Service 中的关系表。
**注意**
当您从 AWS Glue 数据目录中删除数据库时，也会删除数据库中的所有表。
要查看数据库列表，请登录 AWS 管理控制台 并通过以下网址打开 AWS Glue 控制台：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。选择 **Databases (数据库)**，然后在列表中选择一个数据库名称以查看详细信息。
从 AWS Glue 控制台中的 **Databases (数据库)** 选项卡上，您可以添加、编辑和删除数据库。
+ 要创建新的数据库，请选择 **Add database (添加数据库)** 并提供名称和描述。为了与其他元数据存储 (如 Apache Hive) 兼容，名称会转换为小写字符。
**注意**
如果您计划从 Amazon Athena 访问数据库，请提供只包含字母数字和下划线字符的名称。有关更多信息，请参阅 [Athena 名称](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html#ate-table-database-and-column-names-allow-only-underscore-special-characters)。
+ 要编辑数据库的说明，请选中数据库名称旁边的复选框，然后选择 **Edit**（编辑）。
+ 要删除数据库，请选中数据库名称旁边的复选框，然后选择 **Remove**（删除）。
+ 要显示数据库中包含的表列表，请选择数据库名称，数据库属性将显示数据库中的所有表。
要更改爬网程序写入的数据库，必须更改爬网程序定义。有关更多信息，请参阅 [使用爬网程序填充 Data Catalog](add-crawler.md)。
## 数据库资源链接
| |
| --- |
| AWS Glue 控制台最近已更新。当前版本的控制台不支持数据库资源链接。 |
数据目录还可以包含到数据库的*资源链接*。数据库资源链接是指向本地或共享数据库的链接。目前，您只能在 AWS Lake Formation 中创建资源链接。创建到数据库的资源链接后，您可以在需要使用数据库名称的任何位置使用资源链接名称。与您拥有的或与您共享的数据库一起，数据库资源链接由 `glue:GetDatabases()` 返回，并在 AWS Glue 控制台的 **Databases (数据库)** 页面上显示为条目。
数据目录还可以包含表资源链接。
有关资源链接的更多信息，请参阅《AWS Lake Formation 开发人员指南》**中的[创建资源链接](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-resource-links.html)。
# 创建表
尽管运行爬网程序是清点数据存储中数据的推荐方法，但您也可以手动将元数据表添加到 AWS Glue Data Catalog 中。通过这种方法，您可以更好地控制元数据定义，并根据您的特定要求对其进行自定义。
您可以通过以下方式向 Data Catalog 中添加表：
+ 使用 AWS Glue 控制台在 AWS Glue Data Catalog 中手动创建一个表。有关更多信息，请参阅 [使用控制台创建表](#console-tables)。
+ 在 [AWS Glue API](aws-glue-api.md) 中使用 `CreateTable` 操作在 AWS Glue Data Catalog 中创建表。有关更多信息，请参阅 [CreateTable 操作（Python：create\$1table）](aws-glue-api-catalog-tables.md#aws-glue-api-catalog-tables-CreateTable)。
+ 使用 CloudFormation 模板。有关更多信息，请参阅 [AWS Glue 的 AWS CloudFormation](populate-with-cloudformation-templates.md)。
当您使用控制台或 API 手动定义表时，您需要指定表架构和分类字段的值（指示数据源中数据的类型和格式）。如果爬网程序创建表，则数据格式和架构由内置分类器或自定义分类器确定。有关使用 AWS Glue 控制台创建表的更多信息，请参阅[使用控制台创建表](#console-tables)。
**Topics**
+ [表分区](#tables-partition)
+ [表资源链接](#tables-resource-links)
+ [使用控制台创建表](#console-tables)
+ [创建分区索引](partition-indexes.md)
+ [使用爬网程序更新手动创建的数据目录表](#update-manual-tables)
+ [数据目录表属性](#table-properties)
## 表分区
Amazon Simple Storage Service（Amazon S3）文件夹的 AWS Glue 表定义可以描述分区表。例如，要提高查询性能，分区表可以使用月份的名称作为键将每月数据分隔为不同的文件。在 AWS Glue 中，表定义包含表的分区键。当 AWS Glue 评估 Amazon S3 文件夹中的数据以编目表时，它确定是否添加了单个表或分区表。
您可以在表上创建分区索引以获取分区的子集，而不是加载表中的所有分区。有关使用分区索引的信息，请参阅[创建分区索引](partition-indexes.md)。
以下 AWS Glue 所有条件都必须为 true，才能为 Amazon S3 文件夹创建分区表：
+ 文件的架构类似，由 AWS Glue 确定。
+ 文件的数据格式是相同的。
+ 文件的压缩格式是相同的。
例如，您可能拥有一个名为 `my-app-bucket` 的 Amazon S3 存储桶，在其中您存储了 iOS 和 Android 应用程序销售数据。该数据按年、月和日分区。适用于 iOS 和 Android 销售的数据文件具有相同的架构、数据格式和压缩格式。在 AWS Glue Data Catalog 中，AWS Glue 爬网程序使用年、月和日的分区键创建一个表定义。
`my-app-bucket` 的以下 Amazon S3 列表显示某些分区。`=` 符号用于分配分区键值。
```
my-app-bucket/Sales/year=2010/month=feb/day=1/iOS.csv
my-app-bucket/Sales/year=2010/month=feb/day=1/Android.csv
my-app-bucket/Sales/year=2010/month=feb/day=2/iOS.csv
my-app-bucket/Sales/year=2010/month=feb/day=2/Android.csv
...
my-app-bucket/Sales/year=2017/month=feb/day=4/iOS.csv
my-app-bucket/Sales/year=2017/month=feb/day=4/Android.csv
```
## 表资源链接
| |
| --- |
| AWS Glue 控制台最近已更新。当前版本的控制台不支持表资源链接。 |
数据目录还可以包含表*资源链接*。表资源链接是指向本地或共享表的链接。目前，您只能在 AWS Lake Formation 中创建资源链接。创建到表的资源链接后，您可以在需要使用表名称的任何位置使用资源链接名称。与您拥有的或与您共享的表一起，表资源链接由 `glue:GetTables()` 返回，并在 AWS Glue 控制台的**表**页面上显示为条目。
数据目录还可以包含数据库资源链接。
有关资源链接的更多信息，请参阅《AWS Lake Formation 开发人员指南》**中的[创建资源链接](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-resource-links.html)。
## 使用控制台创建表
AWS Glue Data Catalog中的表是表示数据存储中的数据的元数据定义。您可以在运行爬网程序时创建表，也可以在 AWS Glue 控制台中手动创建表。AWS Glue 控制台中的 **Tables (表)** 列表显示表的元数据值。您可以在创建 ETL (提取、转换和加载) 作业时使用表定义来指定源和目标。
**注意**
随着最近对 AWS 管理控制台的更改，您可能需要修改现有的 IAM 角色才能获得 [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-SearchTables](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-SearchTables) 权限。对于创建新角色，已将 `SearchTables` API 权限添加为默认。
要查看现有任务，请登录 AWS 管理控制台 并通过以下网址打开 AWS Glue 控制台：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。选择 **Tables** (表) 选项卡，然后使用 **Add tables** (添加表) 按钮来通过爬网程序或通过手动键入属性来创建表。
### 在控制台上添加表
要使用爬网程序添加表，请依次选择 **Add tables** (添加表) 和 **Add tables using a crawler** (使用爬网程序添加表)。然后按照 **Add crawler** (添加爬网程序) 向导中的说明操作。当爬网程序运行时，会将表添加到 AWS Glue Data Catalog。有关更多信息，请参阅 [使用爬网程序填充 Data Catalog](add-crawler.md)。
如果您知道在数据目录中创建 Amazon Simple Storage Service（Amazon S3）表定义所需的属性，则可以使用表向导创建它。请依次选择 **Add tables** (添加表) 和 **Add table manually** (手动添加表)，然后按照 **Add tables** (添加表) 向导中的说明操作。
在通过控制台手动添加表时，请考虑以下各项：
+ 如果您计划从 Amazon Athena 访问表，请提供只包含字母数字和下划线字符的名称。有关更多信息，请参阅 [Athena 名称](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html#ate-table-database-and-column-names-allow-only-underscore-special-characters)。
+ 源数据的位置必须是 Amazon S3 路径。
+ 数据的数据格式必须与向导中列出的格式之一匹配。将基于所选的格式自动填充相应的分类、SerDe 和其他表属性。您可以使用以下格式定义表：
**Avro**
Apache Avro JSON 二进制格式。
**CSV**
字符分隔值。您还可以指定逗号、竖线、分号、制表符或 Ctrl-A 等分隔符。
**JSON**
JavaScript 对象表示法。
**XML**
可扩展标记语言格式。指定定义数据中行的 XML 标签。在行标签中定义列。
**Parquet**
Apache Parquet 列式存储。
**ORC**
优化的行列式（ORC）格式。一种旨在高效存储 Hive 数据的格式。
+ 您可以为表定义分区键。
+ 目前，使用控制台创建的分区表不能用于 ETL 任务。
### 表属性
以下是表的一些重要属性：
**名称**
在创建表时确定名称，并且您无法更改它。您在许多 AWS Glue 操作中引用表名称。
**数据库**
表所在的容器对象。此对象包含 AWS Glue Data Catalog中存在的表组织，并且可能与您的数据存储中的组织不同。当您删除数据库时，也会从数据目录中删除数据库中包含的所有表。
**说明**
表的描述。您可以编写描述以帮助您了解表的内容。
**表格式**
指定创建标准 AWS Glue 表或 Apache Iceberg 格式的表。
Data Catalog 提供以下表优化选项，以管理表存储并提高 Iceberg 表的查询性能。
+ **压缩** – 此功能会合并和重写数据文件以移除过时数据，并将碎片数据合并到更大、更高效的文件中。
+ **快照保留** – 快照是带有时间戳的 Iceberg 表版本。借助快照保留配置，客户可以强制规定快照保留期限和要保留的快照数量。配置快照保留优化器可以移除不必要的旧快照及其相关底层文件，从而帮助管理存储开销。
+ **孤立文件删除** – 孤立文件是指不再被 Iceberg 表元数据引用的文件。这些文件可能会逐渐堆积，尤其是在表删除或 ETL 任务失败等操作之后。启用孤立文件删除功能后，AWS Glue 会定期识别并移除这些不必要的文件，从而释放存储空间。
有关更多信息，请参阅 [优化 Iceberg 表](table-optimizers.md)。
**优化配置**
您可以通过使用默认设置或对设置进行自定义来启用表优化器。
**IAM 角色**
为了运行表优化器，该服务会代表您代入一个 IAM 角色。您可以使用下拉列表选择一个 IAM 角色。确保该角色具有启用压缩所需的权限。
要了解该 IAM 角色所需的权限，请参阅 [表优化的先决条件](optimization-prerequisites.md)。
**位置**
指向此表定义表示的数据存储中的数据位置的指针。
**分类**
在创建表时提供的分类值。通常，在爬网程序运行并指定源数据格式时写入它。
**上次更新时间**
在数据目录中更新此表的日期和时间（UTC）。
**日期已添加**
此表添加到数据目录中的日期和时间（UTC）。
**已弃用**
如果 AWS Glue 发现数据目录中的表不再存在于其原始数据存储中，则会在数据目录中将此表标记为已淘汰。如果您运行的作业引用已淘汰的表，则此作业可能会失败。编辑引用已淘汰的表的作业，以从源和目标中删除这些表。我们建议您删除不再需要的已淘汰的表。
**Connection**
如果 AWS Glue 需要连接到您的数据存储，则连接的名称与表相关联。
### 查看和管理表详细信息
要查看现有表的详细信息，请在列表中选择表名称，然后选择 **Action, View details** (操作 -> 查看详细信息)。
表详细信息包括表的属性和架构。此视图显示表的架构，包括按为表定义的顺序排列的列名称、数据类型和分区的键列。如果列是复杂类型，您可以选择 **View properties** (查看属性) 来显示该字段的结构的详细信息，如以下示例所示：
```
{
"StorageDescriptor":
{
"cols": {
"FieldSchema": [
{
"name": "primary-1",
"type": "CHAR",
"comment": ""
},
{
"name": "second ",
"type": "STRING",
"comment": ""
}
]
},
"location": "s3://aws-logs-111122223333-us-east-1",
"inputFormat": "",
"outputFormat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"compressed": "false",
"numBuckets": "0",
"SerDeInfo": {
"name": "",
"serializationLib": "org.apache.hadoop.hive.serde2.OpenCSVSerde",
"parameters": {
"separatorChar": "|"
}
},
"bucketCols": [],
"sortCols": [],
"parameters": {},
"SkewedInfo": {},
"storedAsSubDirectories": "false"
},
"parameters": {
"classification": "csv"
}
}
```
有关表的属性的更多信息，如 `StorageDescriptor`，请参阅 [StorageDescriptor 结构](aws-glue-api-catalog-tables.md#aws-glue-api-catalog-tables-StorageDescriptor)。
要更改表的架构，请选择 **Edit schema** (编辑架构) 来添加和删除列、更改列名称以及更改数据类型。
要比较不同版本的表，包括其架构，请选择 **Compare versions** (比较版本) 来查看表架构的两个版本之间的逐项对照比较。有关更多信息，请参阅 [比较表架构版本](#console-tables-schema-comparison)。
要显示组成 Amazon S3 分区的文件，请选择 **View partition (查看分区)**。对于 Amazon S3 表，**Key (键)** 列显示用于对源数据存储中的表进行分区的分区键。分区是根据键列（如日期、位置或部门）的值将表划分为多个相关部分的方法。有关分区的更多信息，请在 Internet 上搜索有关“hive 分区”的信息。
**注意**
要获取查看表详细信息的分步指导，请参阅控制台中的 **Explore table** (浏览表) 教程。
### 比较表架构版本
比较两个版本的表架构时，可以通过展开和折叠嵌套行来比较嵌套行更改，并排比较两个版本的架构，并排查看表属性。
要比较版本，请执行以下操作。
1. 在 AWS Glue 控制台中选择**表**，然后选择**操作**，再选择**比较版本**。
![\[屏幕截图显示选中时的“操作”按钮。下拉菜单显示比较版本选项。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/catalog-table-compare-versions.png)
1. 通过选择版本下拉菜单来选择要比较的版本。比较架构时，架构选项卡突出显示为橙色。
1. 比较两个版本之间的表时，将在屏幕的左侧和右侧分别显示表架构。便于您通过并排比较列名称、数据类型、键和注释字段来直观地确定更改。对于有更改的地方，彩色图标会显示所做更改的类型。
+ 已删除：红色图标表示该列已从先前版本的表架构中删除。
+ 已编辑或移动：蓝色图标表示在较新版本的表架构中被修改或移动的列。
+ 已添加：绿色图标表示被添加到新版表架构中的列。
+ 嵌套更改：黄色图标表示包含更改的嵌套列。选择要展开的列并查看已删除、编辑、移动或添加的列。
![\[屏幕截图显示了两个版本之间的表架构比较。左侧是旧版本。右侧是较新的版本。删除图标位于从旧版本中删除的列旁边，该列已不在较新版本中。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/catalog-table-version-comparison.png)
1. 使用筛选字段搜索栏根据您在此处输入的字符显示字段。如果您在任一表版本中输入列名，筛选后的字段将显示在两个表版本中，以显示发生更改的位置。
1. 要比较属性，请选择**属性**选项卡。
1. 要停止比较版本，请选择**停止比较**返回表列表。
# 创建分区索引
随着时间的推移，数十万个分区被添加到一个表中。[GetPartitions API](https://docs.aws.amazon.com/glue/latest/webapi/API_GetPartitions.html) 用于获取表中的分区。API 返回与请求中提供的表达式匹配的分区。
让我们以 *sales\$1data* 表为例，该表依据 *Country*、*Category*、*Year*、*Month* 和 *creationDate* 键进行分区。如果您想获得 2020 年 *2020-08-15* 以后 *Books* 类别所有已售出商品的销售数据，则必须使用表达式 "Category = 'Books' and creationDate > '2020-08-15'" 向数据目录发出 `GetPartitions` 请求。
如果表中没有分区索引，则 AWS Glue 加载表的所有分区，然后使用用户在 `GetPartitions` 请求中提供的查询表达式筛选加载的分区。随着没有索引的表上的分区数量的增加，查询需要更多的时间来运行。借助索引，`GetPartitions` 查询将尝试获取分区的子集，而不是加载表中的所有分区。
**Topics**
+ [关于分区索引](#partition-index-1)
+ [使用分区索引创建表](#partition-index-creating-table)
+ [将分区索引添加到现有表](#partition-index-existing-table)
+ [描述表上的分区索引](#partition-index-describing)
+ [使用分区索引的限制](#partition-index-limitations)
+ [使用索引进行优化的 GetPartitions 调用](#partition-index-getpartitions)
+ [与引擎集成](#partition-index-integration-engines)
## 关于分区索引
当您创建分区索引时，请指定给定表中已存在的分区键列表。分区索引是表中定义的分区键的子列表。可以在表中定义的分区键的任何排列上创建分区索引。对于上面的 *sales\$1data* 表，可能的索引有 (country, category, year, creationDate)、(country, category, year)、(country, category)、(country)、(category, country, year, month) 等。
数据目录将按照创建索引时提供的顺序连接分区值。随着分区被添加到表中，索引的构建是一致的。可以为字符串（string、char 和 varchar）、数值（int、bigint、long、tinyint 和 smallint）和日期 (yyyy-MM-dd) 列类型创建索引。
**支持的数据类型**
+ 日期 – ISO 格式的日期，例如 `YYYY-MM-DD`。例如，date `2020-08-15`。该格式使用连字符（-）来分隔年月日。允许的日期索引范围为 `0000-01-01` 到 `9999-12-31`。
+ 字符串 – 用单引号或双引号括起的字符串文本。
+ Char – 固定长度字符数据，指定长度介于 1 到 255 之间，例如 char(10)。
+ Varchar – 可变长度字符数据，具有介于 1 和 65535 之间的指定长度，例如 varchar(10)。
+ 数值 – int、bigint、long、tinyint 和 smallint
数值、字符串和日期数据类型的索引支持 =、>、>=、<、<= 以及 between（介于）运算符。索引解决方案目前仅支持 `AND` 逻辑运算符。在使用索引进行筛选的表达式中，将忽略带有运算符“LIKE”、“IN”、“OR”和“NOT”的子表达式。对被忽略的子表达式的筛选是在应用索引筛选后获取的分区上完成的。
对于添加到表中的每个分区，都会创建一个相应的索引项。对于具有“n”个分区的表，1 个分区索引将生成“n”个分区索引项。同一个表上的“m”个分区索引将生成“m\$1n”个分区索引项。每个分区索引项将根据数据目录存储的当前 AWS Glue 定价策略收费。有关存储对象定价的详细信息，请参阅 [AWS Glue 定价](https://aws.amazon.com/glue/pricing/)。
## 使用分区索引创建表
您可以在表创建过程中创建分区索引。`CreateTable` 请求将 [`PartitionIndex` 对象](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-PartitionIndex)列表作为输入。在给定的表上最多可以创建 3 个分区索引。每个分区索引都需要一个名称和一个为表定义的 `partitionKeys` 列表。可以使用 [`GetPartitionIndexes` API](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-GetPartitionIndexes) 获取在表上创建的索引
## 将分区索引添加到现有表
要将分区索引添加到现有表，请使用 `CreatePartitionIndex` 操作。您只能为每个 `CreatePartitionIndex` 操作创建一个 `PartitionIndex`。添加索引不会影响表的可用性，因为在创建索引期间该表继续可用。
添加的分区的索引状态设置为“CREATING (正在创建)”，并开始创建索引数据。如果创建索引的过程成功，则 indexStatus 将更新为“ACTIVE (活跃)”，对于不成功的过程，索引状态将更新为“FAILED (失败)”。索引创建可能会因多种原因而失败，您可以使用 `GetPartitionIndexes` 操作检索失败详细信息。可能出现的故障包括：
+ ENCRYPTED\$1PARTITION\$1ERROR – 不支持在具有加密分区的表上创建索引。
+ NVALID\$1PARTITION\$1TYPE\$1DATA\$1ERROR – 当 `partitionKey` 值不是相应 `partitionKey` 数据类型的有效值时观察到。例如：具有“int”数据类型的 `partitionKey` 的值为“foo”。
+ MISSING\$1PARTITION\$1VALUE\$1ERROR – 当 `indexedKey` 的 `partitionValue` 不存在时观察到。当表的分区不一致时可能会发生这种情况。
+ UNSUPPORTED\$1PARTITION\$1CHARACTER\$1ERROR – 当索引分区键的值包含字符 \$1u0000、\$1u0001 或 \$1u0002 时观察到的
+ INTERNAL\$1ERROR – 在创建索引时发生内部错误。
## 描述表上的分区索引
要获取在表上创建的分区索引，请使用 `GetPartitionIndexes` 操作。响应返回表上的所有索引，以及每个索引的当前状态（`IndexStatus`）。
分区索引的 `IndexStatus` 将是以下之一：
+ `CREATING` – 索引当前正在创建中，尚不能使用。
+ `ACTIVE` – 索引已准备就绪，可供使用。请求可以使用索引执行优化查询。
+ `DELETING` – 索引当前正在被删除，无法再使用。可以使用 `DeletePartitionIndex` 请求删除处于活动状态的索引，这会将状态从“ACTIVE (活跃)”移至“DELETING (正在删除)”。
+ `FAILED` – 在现有表上创建索引失败。每个表存储最后 10 个失败的索引。
在现有表上创建的索引的可能状态转换包括：
+ CREATING (正在创建) → ACTIVE (活跃) → DELETING (正在删除)
+ CREATING (正在创建) → FAILED (失败)
## 使用分区索引的限制
创建分区索引后，请注意对表和分区功能的以下更改：
**创建新分区（添加索引后）**
在表上创建分区索引后，添加到表中的所有新分区都将针对索引键的数据类型检查进行验证。索引键的分区值将针对数据类型格式进行验证。如果数据类型检查失败，则创建分区操作将失败。对于 *sales\$1data* 表，如果为类别为类型 `string` 且年份为类型 `int` 的键 (category, year) 创建索引，则创建 YEAR 值为“foo”的新分区将失败。
启用索引后，添加具有字符 U\$10000、U\$100001 和 U\$10002 的索引键值的分区将开始失败。
**表更新**
在表上创建分区索引后，您将无法修改现有分区键的分区键名称，也无法更改向该索引注册的键的类型或顺序。
## 使用索引进行优化的 GetPartitions 调用
当您在具有索引的表上调用 `GetPartitions` 时，您可以包含一个表达式，如果可能，数据目录将使用索引。索引的第一个键应传递到要用于筛选的索引的表达式中。筛选中的索引优化基于最佳效果应用。数据目录尝试尽可能多地使用索引优化，但在缺少索引或不支持的运算符的情况下，它会回退到加载所有分区的现有实现。
对于上面的 *sales\$1data* 表，让我们添加索引 [Country, Category, Year]。如果表达式中未传递“Country”，则注册的索引将无法使用索引筛选分区。您最多可以添加 3 个索引来支持各种查询模式。
让我们举一些示例表达式，看看索引是如何处理它们的：
| Expressions | 如何使用索引 |
| --- | --- |
| Country = 'US' | 索引将用于筛选分区。 |
| Country = 'US' and Category = 'Shoes' | 索引将用于筛选分区。 |
| Category = 'Shoes' | 不会使用索引，因为表达式中未提供“country”。将加载所有分区以返回响应。 |
| Country = 'US' and Category = 'Shoes' and Year > '2018' | 索引将用于筛选分区。 |
| Country = 'US' and Category = 'Shoes' and Year > '2018' and month = 2 | 索引将用于获取 country = "US" 和 category = "shoes" 且 year > 2018 的所有分区。然后，将执行月份表达式的筛选。 |
| Country = 'US' AND Category = 'Shoes' OR Year > '2018' | 由于表达式中存在 `OR` 运算符，因此不会使用索引。 |
| Country = 'US' AND Category = 'Shoes' AND (Year = 2017 OR Year = '2018') | 索引将用于获取所有 country = "US" 和 category = "shoes" 的分区，然后对年份表达式进行筛选。 |
| Country in ('US', 'UK') AND Category = 'Shoes' | 索引不会用于筛选，因为当前不支持 `IN` 运算符。 |
| Country = 'US' AND Category in ('Shoes', 'Books') | 索引将用于获取所有 country = "US" 的分区，然后对 Category 表达式进行筛选。 |
| Country = 'US' AND Category in ('Shoes', 'Books') AND (creationDate > '2023-9-01' | 索引将用于获取所有 country = "US" 且 creationDate > '2023-9-01' 的分区，然后对 Category 表达式进行筛选。 |
## 与引擎集成
Redshift Spectrum、Amazon EMR 和 AWS Glue ETL Spark DataFrames 能够在 AWS Glue 中的索引处于 ACTIVE 状态后利用索引来获取分区。[Athena](https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index) 和 [AWS Glue ETL Dynamic frames](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-cat-predicates) 要求您执行额外的步骤以利用索引来改进查询。
### 启用分区筛选
要在 Athena 中启用分区筛选，您需要按如下方式更新表属性：
1. 在 AWS Glue 控制台中，选择 **Data Catalog** 下的**表**。
1. 选择一个表。
1. 在**操作**下，选择**编辑表**。
1. 在**表属性**下，添加以下内容：
+ 键 – `partition_filtering.enabled`
+ 值 – `true`
1. 选择**应用**。
您还可以通过在 Athena 中运行 [ALTER TABLE SET PROPERTIES](https://docs.aws.amazon.com/athena/latest/ug/alter-table-set-tblproperties.html) 查询来设置此参数。
```
ALTER TABLE partition_index.table_with_index
SET TBLPROPERTIES ('partition_filtering.enabled' = 'true')
```
## 使用爬网程序更新手动创建的数据目录表
您可能需要手动创建 AWS Glue Data Catalog 表，然后将它们保持为通过 AWS Glue 爬网程序进行更新。按计划运行的爬网程序可以添加新分区，并使用任何架构更改来更新表。这同样适用于从 Apache Hive 元存储中迁移的表。
要执行此操作，当您定义爬网程序时，不是指定一个或多个数据存储作为爬取源，而是指定一个或多个现有数据目录表。然后，爬网程序爬取由目录表指定的数据存储。在这种情况下，不会创建新表；而是更新手动创建的表。
以下是您可能需要手动创建目录表并将目录表指定为爬网程序源的其他原因：
+ 您想要选择目录表名称，但不依赖于目录表命名算法。
+ 在将其格式可能损坏分区检测的文件错误地保存在数据源路径的情况下，您可能希望阻止创建新表。
有关更多信息，请参阅 [步骤 2：选择数据源和分类器](define-crawler-choose-data-sources.md)。
## 数据目录表属性
AWS CLI 中已知的表属性或参数是未经验证的键值字符串。您可以在表上设置自己的属性，以支持在 AWS Glue 之外使用数据目录。其他使用数据目录的服务也可以执行该操作。AWS Glue 会在运行作业或爬网程序时设置一些表属性。除非另有说明，否则这些属性仅供内部使用，我们不支持它们继续以其当前形式存在，也不支持手动更改这些属性的产品行为。
更多有关 AWS Glue 爬网程序设置的表属性的信息，请参阅 [爬网程序在数据目录表上设置的参数](table-properties-crawler.md)。
# 与 Amazon S3 表类数据存储服务集成
利用 AWS Glue Data Catalog 与 Amazon S3 表类数据存储服务的集成，您可以使用单个目录发现、查询 Amazon S3 数据湖中的数据以及将 S3 表类数据存储服务与这些数据联接。当您将 S3 表类数据存储服务与 Data Catalog 集成时，该服务会创建一个联合目录结构来将 S3 表类数据存储服务资源映射到 AWS Glue 目录对象：
+ S3 表类数据存储服务存储桶成为 Data Catalog 中的目录
+ S3 命名空间变为 AWS Glue 数据库
+ S3 表变为 AWS Glue 表
## 访问控制
Data Catalog 对 S3 表类数据存储服务集成支持两种访问控制模式：
+ **IAM 访问控制**：使用 IAM 策略控制对 S3 表类数据存储服务和 Data Catalog 的访问。在这种方法中，您需要对 S3 表类数据存储服务资源和 Data Catalog 对象拥有 IAM 权限才能访问资源。
+ **AWS Lake Formation 访问控制**：除了 AWS Glue IAM 权限外，还使用 AWS Lake Formation 授权通过 Data Catalog 控制对 S3 表类数据存储服务的访问。在此模式下，主体需要 IAM 权限才能与 Data Catalog 交互，AWS Lake Formation 授权确定主体可以访问哪些目录资源（数据库、表、列、行）。此模式支持粗粒度访问控制（数据库级和表级授权）和精细访问控制（列级和行级安全）。配置了注册角色并启用凭证售卖后，主体不需要 S3 表类数据存储服务 IAM 权限，因为 AWS Lake Formation 使用注册角色代表主体售卖凭证。AWS Lake Formation 访问控制还支持第三方分析引擎的凭证售卖。有关更多信息，请参阅《AWS Lake Formation 开发人员指南》**中的 [Creating an S3 Tables catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-s3-tables-catalog.html)。
您可以根据要求变化在不同的访问控制模式之间进行迁移。
## 自动挂载的目录层次结构
当您使用 Amazon S3 管理控制台将 S3 表类数据存储服务与 Data Catalog 集成时，控制台会在该 AWS 区域您的账户中的 Data Catalog 中创建名为 `s3tablescatalog` 的联合目录。此联合目录充当该账户和区域中所有现有和未来 S3 表存储桶的父目录。该集成按以下层次结构映射 Amazon S3 表存储桶资源：
+ **联合目录**：`s3tablescatalog`（自动创建）
+ **子目录**：每个 S3 表存储桶变为 `s3tablescatalog` 下的子目录
+ **数据库**：表存储桶中的每个 S3 命名空间变为数据库
+ **表**：命名空间中的每个 S3 表变为一个表
例如，如果您有名为“analytics-bucket”的 S3 表存储桶，其命名空间为“sales”，其中包含表“transactions”，则 Data Catalog 中的完整路径将是：`s3tablescatalog/analytics-bucket/sales/transactions`
此由四部分组成的分层结构适用于 S3 表类数据存储服务和 Data Catalog 位于同一 AWS 账户中的同一账户方案。对于跨账户方案，您可以在 Data Catalog 中手动挂载单个 S3 表存储桶，这将创建一个由三部分组成的层次结构。
## 支持的区域：
以下 AWS 区域提供 S3 表类数据存储服务与 Data Catalog 的集成：
| 区域代码 | 区域名称 |
| --- | --- |
| us-east-1 | 美国东部（弗吉尼亚州北部） |
| us-east-2 | 美国东部（俄亥俄州） |
| us-west-1 | 美国西部（北加利福尼亚） |
| us-west-2 | 美国西部（俄勒冈州） |
| af-south-1 | 非洲（开普敦） |
| ap-east-1 | 亚太地区（香港） |
| ap-east-2 | 亚太地区（台北） |
| ap-northeast-1 | 亚太地区（东京） |
| ap-northeast-2 | 亚太地区（首尔） |
| ap-northeast-3 | 亚太地区（大阪） |
| ap-south-1 | 亚太地区（孟买） |
| ap-south-2 | 亚太地区（海得拉巴） |
| ap-southeast-1 | 亚太地区（新加坡） |
| ap-southeast-2 | 亚太地区（悉尼） |
| ap-southeast-3 | 亚太地区（雅加达） |
| ap-southeast-4 | 亚太地区（墨尔本） |
| ap-southeast-5 | 亚太地区（马来西亚） |
| ap-southeast-6 | 亚太地区（新西兰） |
| ap-southeast-7 | 亚太地区（泰国） |
| ca-central-1 | 加拿大（中部） |
| ca-west-1 | 加拿大西部（卡尔加里） |
| eu-central-1 | 欧洲地区（法兰克福） |
| eu-central-2 | 欧洲（苏黎世） |
| eu-north-1 | 欧洲地区（斯德哥尔摩） |
| eu-south-1 | 欧洲地区（米兰） |
| eu-south-2 | 欧洲（西班牙） |
| eu-west-1 | 欧洲地区（爱尔兰） |
| eu-west-2 | 欧洲地区（伦敦） |
| eu-west-3 | 欧洲地区（巴黎） |
| il-central-1 | 以色列（特拉维夫） |
| mx-central-1 | 墨西哥（中部） |
| sa-east-1 | 南美洲（圣保罗） |
**Topics**
+ [访问控制](#s3-tables-access-controls)
+ [自动挂载的目录层次结构](#s3-tables-catalog-hierarchy)
+ [支持的区域：](#s3-tables-supported-regions)
+ [先决条件](s3tables-catalog-prerequisites.md)
+ [启用 S3 表类数据存储服务与 Data Catalog 的集成](enable-s3-tables-catalog-integration.md)
+ [向 S3 表类数据存储服务目录添加数据库和表](create-databases-tables-s3-catalog.md)
+ [共享 S3 表类数据存储服务目录对象](share-s3-tables-catalog.md)
+ [管理 S3 表类数据存储服务集成](manage-s3-tables-catalog-integration.md)
# 先决条件
在为 AWS Glue Data Catalog 中的 S3 表类数据存储服务创建联合目录之前，请确保您的 IAM 主体（用户或角色）具有所需的权限。
## 所需的 IAM 权限
IAM 主体需要以下权限才能启用 S3 表类数据存储服务集成：
**AWS Glue 权限**：
+ `glue:CreateCatalog`：创建 `s3tablescatalog` 联合目录所必需的
+ `glue:GetCatalog`：查看目录详细信息所必需的
+ `glue:GetDatabase`：以数据库形式查看 S3 命名空间所必需的
+ `glue:GetTable`：查看 S3 表类数据存储服务所必需的
+ `glue:passConnection`：授予调用主体将 `aws:s3tables` 连接委托给 AWS Glue 服务的权限
**S3 表类数据存储服务权限**（用于 IAM 访问控制）：
+ `s3tables:CreateTableBucket`
+ `s3tables:GetTableBucket`
+ `s3tables:CreateNamespace`
+ `s3tables:GetNamespace`
+ `s3tables:ListNamespaces`
+ `s3tables:CreateTable`
+ `s3tables:GetTable`
+ `s3tables:ListTables`
+ `s3tables:UpdateTableMetadataLocation`
+ `s3tables:GetTableMetadataLocation`
+ `s3tables:GetTableData`
+ `s3tables:PutTableData`
## IAM 策略示例
以下 IAM 策略提供了在 IAM 模式下启用 S3 表类数据存储服务与 Data Catalog 的集成所需的最低权限：
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GlueDataCatalogPermissions",
"Effect": "Allow",
"Action": [
"glue:CreateCatalog",
"glue:GetCatalog",
"glue:GetDatabase",
"glue:GetTable"
],
"Resource": [
"arn:aws:glue:region:account-id:catalog/s3tablescatalog",
"arn:aws:glue:region:account-id:database/s3tablescatalog/*/*",
"arn:aws:glue:region:account-id:table/s3tablescatalog/*/*/*"
]
},
{
"Sid": "S3TablesDataAccessPermissions",
"Effect": "Allow",
"Action": [
"s3tables:GetTableBucket",
"s3tables:GetNamespace",
"s3tables:GetTable",
"s3tables:GetTableMetadataLocation",
"s3tables:GetTableData"
],
"Resource": [
"arn:aws:s3tables:region:account-id:bucket/*",
"arn:aws:s3tables:region:account-id:bucket/*/table/*"
]
}
]
}
```
# 启用 S3 表类数据存储服务与 Data Catalog 的集成
您可以使用 Amazon S3 管理控制台或 AWS CLI 启用 S3 表类数据存储服务与 AWS Glue Data Catalog 的集成。使用控制台启用集成时，AWS 会创建名为 `s3tablescatalog` 的联合目录，其会自动发现并挂载您的 AWS 账户和区域中的所有 S3 表存储桶。
## 使用 Amazon S3 管理控制台启用 S3 表类数据存储服务集成
1. 通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**表存储桶**。
1. 选择**创建表存储桶**。
1. 输入**表存储桶名称**，并确保选中**启用集成**复选框。
1. 选择**创建表存储桶**。
Amazon S3 会自动在该区域中集成您的表存储桶。首次在任何区域中集成表存储桶时，Amazon S3 都会在该区域的 Data Catalog 中创建 `s3tablescatalog`。
创建目录后，您的账户和区域中的所有 S3 表存储桶都会自动作为子目录挂载。您可以通过导航到 Data Catalog 中的目录来查看数据库（命名空间）和表。
## 使用 AWS CLI 启用 S3 表类数据存储服务集成
使用 `s3tablescatalog` 命令创建 `glue create-catalog` 目录。
```
aws glue create-catalog \
--name "s3tablescatalog" \
--catalog-input '{
"Description": "Federated catalog for S3 Tables",
"FederatedCatalog": {
"Identifier": "arn:aws:s3tables:region:account-id:bucket/*",
"ConnectionName": "aws:s3tables"
},
"CreateDatabaseDefaultPermissions": [{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": ["ALL"]
}],
"CreateTableDefaultPermissions": [{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": ["ALL"]
}]
}'
```
将 *region* 替换为您的 AWS 区域，并将 *account-id* 替换为您的 AWS 账户 ID。
## 验证集成
创建目录后，您可以通过列出子目录来验证是否已挂载 S3 表存储桶：
```
aws glue get-catalogs \
--parent-catalog-id s3tablescatalog
```
# 向 S3 表类数据存储服务目录添加数据库和表
确保您拥有在您所在区域的 Data Catalog 中列出和创建目录、数据库和表所需的权限。确保在您的 AWS 账户和区域中启用 S3 表类数据存储服务集成。
## 向 S3 表类数据存储服务目录添加数据库
### 添加数据库（控制台）
1. 打开 AWS Glue 控制台，地址：[https://console.aws.amazon.com/glue/home](https://console.aws.amazon.com/glue/home)。
1. 在左侧导航窗格中，选择**数据库**。
1. 选择 **添加数据库**。
1. 选择 **S3 表类数据存储服务联合目录中的 Glue 数据库**。
1. 输入数据库的唯一名称。
1. 选择与 S3 表类数据存储服务中的表存储桶对应的目标目录。
1. 选择 **Create Database**（创建数据库）。
### 添加数据库 (AWS CLI)
```
aws glue create-database \
--region region \
--catalog-id "account-id:s3tablescatalog/my-catalog" \
--database-input '{"Name": "my-database"}'
```
## 向 S3 表类数据存储服务目录添加表
### 添加表（控制台）
1. 打开 AWS Glue 控制台，地址：[https://console.aws.amazon.com/glue/home](https://console.aws.amazon.com/glue/home)。
1. 在左侧导航窗格中，选择 **表**。
1. 在目录下拉列表中选择相应的 S3 表类数据存储服务目录。
1. 选择**添加表**。
1. 输入表的唯一名称。
1. 确认在目录下拉列表中选择了正确的 S3 表类数据存储服务目录。
1. 在数据库下拉列表中选择数据库。
1. 通过输入 JSON 或单独添加每列来输入表架构。
1. 选择**创建表**。
### 添加表 (AWS CLI)
```
aws glue create-table \
--region region \
--catalog-id "account-id:s3tablescatalog/my-catalog" \
--database-name "my-database" \
--table-input '{
"Name": "my-table",
"Parameters": {
"classification": "",
"format": "ICEBERG"
},
"StorageDescriptor": {
"Columns": [
{"Name": "id", "Type": "int", "Parameters": {}},
{"Name": "val", "Type": "string", "Parameters": {}}
]
}
}'
```
# 共享 S3 表类数据存储服务目录对象
使用 IAM 访问控制时，您可以使用用于同一账户共享的 AWS Glue 资源链接与其他用户共享 S3 表类数据存储服务目录对象。对于跨账户共享，您可以与其他 AWS 账户共享 S3 表存储桶，收件人账户中的 IAM 角色或用户可以使用共享的表存储桶创建 AWS Glue 目录对象。
## 使用资源链接在同一账户内共享
利用资源链接可以创建对 AWS Glue 默认目录中出现的 `s3tablescatalog` 中 AWS Glue 数据库和表的引用。这对于组织数据访问或创建表的逻辑分组很有用。
### 创建资源链接（控制台）
1. 通过 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 打开 AWS Glue 控制台。
1. 在导航窗格中，选择**目录**。
1. 在**目录**列表中，选择 **s3tablescatalog**。
1. 从 `s3tablescatalog` 中选择要共享的表。
1. 选择**操作**，然后选择**创建资源链接**。
1. 对于**资源链接名称**，输入资源链接的名称。
1. 对于**目标数据库**，选择要创建资源链接的数据库。
1. （可选）对于**描述**，输入描述。
1. 选择**创建**。
资源链接出现在目标数据库中，并指向 `s3tablescatalog` 中的原始表。
### 创建资源链接 (AWS CLI)
创建数据库资源链接：
```
aws glue create-database \
--database-name "my-database-resource-link" \
--database-input '{
"Name": "sales_data_link",
"TargetDatabase": {
"CatalogId": "account-id:s3tablescatalog/analytics-bucket",
"DatabaseName": "sales"
}
}'
```
创建表资源链接：
```
aws glue create-table \
--table-name "my-table-resource-link" \
--table-input '{
"Name": "sales_data_link",
"TargetTable": {
"CatalogId": "account-id:s3tablescatalog/analytics-bucket",
"DatabaseName": "sales",
"Name": "transactions"
}
}'
```
# 管理 S3 表类数据存储服务集成
## 启用了 AWS Lake Formation
当您想要扩展数据治理要求时，可以为 S3 表类数据存储服务目录启用 AWS Lake Formation。AWS Lake Formation 提供数据库式授权来管理精细访问权限，使用基于标签的访问扩展权限，以及根据用户属性（例如与 S3 表类数据存储服务中表的组关联）授予权限。
转到 AWS Lake Formation 管理控制台，在 AWS Glue 中为 S3 表类数据存储服务目录启用 AWS Lake Formation。有关更多信息，请参阅《AWS Lake Formation 开发人员指南》**中的 [Creating an S3 Tables catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-s3-tables-catalog.html)。
## 删除 S3 表类数据存储服务集成
您可以通过删除 Data Catalog 中的目录集成来删除 S3 表类数据存储服务集成。此操作仅删除 Data Catalog 中的元数据，而不删除 S3 表类数据存储服务中的资源。
确保您具备列出、编辑和删除 AWS Glue 中的目录对象所需的权限。
### 删除集成（控制台）
1. 打开 AWS Glue 控制台，地址：[https://console.aws.amazon.com/glue/home](https://console.aws.amazon.com/glue/home)。
1. 在导航窗格中，选择**目录**。
1. 在**目录**列表中，选择 **s3tablescatalog**。
1. 选择**删除**。
1. 确认删除目录也会删除 Data Catalog 中所有关联的目录对象。
1. 选择**删除**。
### 删除集成 (AWS CLI)
```
aws glue delete-catalog \
--region region \
--catalog-id "s3tablescatalog"
```
# 与其他 AWS 服务集成
虽然您可以使用 AWS Glue 爬网程序 来填充 AWS Glue Data Catalog，但有几种 AWS 服务可以自动与目录集成并为您填充目录。以下各节提供了有关可填充 Data Catalog 的特定用例（由 AWS 服务提供支持）的更多信息。
**Topics**
+ [AWS Lake Formation](#lf-dc)
+ [Amazon Athena](#ate-dc)
## AWS Lake Formation
AWS Lake Formation 是一项服务，让用户能够在 AWS 中更轻松地设置安全数据湖。Lake Formation 建立在 AWS Glue 之上，而 Lake Formation 与 AWS Glue 共享相同的 AWS Glue Data Catalog。您可以在 Lake Formation 中注册您的 Amazon S3 数据位置，然后使用 Lake Formation 控制台在 AWS Glue Data Catalog 中创建数据库和表、定义数据访问策略，并从一个中央位置审核数据湖中的数据访问。您可以使用 Lake Formation 细粒度访问控制来管理现有的数据目录资源和 Amazon S3 数据位置。
凭借在 Lake Formation 中注册的数据，您可以在 IAM 主体、AWS 账户、AWS 组织和组织单位之间安全地共享 Data Catalog 资源。
有关使用 Lake Formation 创建 Data Catalog 资源的更多信息，请参阅《AWS Lake Formation Developer Guide》中的 [Creating Data Catalog tables and databases](https://docs.aws.amazon.com/lake-formation/latest/dg/populating-catalog.html)。
## Amazon Athena
Amazon Athena 使用 Data Catalog 在 AWS 账户中存储和检索 Amazon S3 数据的表元数据。通过表元数据，Athena 查询引擎可以了解如何查找、读取和处理您要查询的数据。
您可以直接使用 Athena `CREATE TABLE` 语句填充 AWS Glue Data Catalog。无需运行爬网程序即可在 Data Catalog 中手动定义和填充架构和分区元数据。
1. 在 Athena 控制台中创建一个数据库，将表元数据存储在 Data Catalog 中。
1. 使用 `CREATE EXTERNAL TABLE` 语句定义数据来源的架构。
1. 使用 `PARTITIONED BY` 子句定义任何分区键（前提是您的数据已分区）。
1. 使用 `LOCATION` 子句指定存储实际数据文件的 Amazon S3 路径。
1. 运行 `CREATE TABLE` 语句。
此查询根据您定义的架构和分区在 Data Catalog 中创建表元数据，而无需实际爬取数据。
您可以在 Athena 中查询表，该表将使用 Data Catalog 中的元数据来访问和查询 Amazon S3 中的数据文件。
有关更多信息，请参阅《Amazon Athena 用户指南》中的[创建数据库和表](https://docs.aws.amazon.com/athena/latest/ug/work-with-data.html)。
# Data Catalog 设置
Data Catalog 设置中包含用于为账户中的 Data Catalog 设置加密和权限的选项。
![\[屏幕截图显示了 Data Catalog 设置模式。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/data_catalog_settings.png)
**更改数据目录的精细访问控制**
1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。
1. 选择加密选项。
+ **元数据加密**：选中此复选框可加密 Data Catalog 中的元数据。系统使用您指定的 AWS Key Management Service (AWS KMS) 密钥对元数据进行静态加密。有关更多信息，请参阅 [加密数据目录](encrypt-glue-data-catalog.md)。
+ **加密连接密码**：选中此复选框可在创建或更新连接时加密 AWS Glue 连接对象中的密码。系统使用您指定的 AWS KMS 密钥对密码进行加密。返回密码时，会对其进行加密。此选项是数据目录中所有 AWS Glue 连接的全局设置。如果清除此复选框，则先前加密的密码会保持加密状态，而密钥就是在以前创建或更新这些密码时所使用的密钥。有关 AWS Glue 连接的更多信息，请参阅 [连接到数据](glue-connections.md)。
启用此选项后，请选择 AWS KMS 密钥，或者选择**输入密钥 ARN** 并提供密钥的 Amazon Resource Name（ARN）。输入 ` arn:aws:kms:region:account-id:key/key-id ` 格式的 ARN。您也可以提供密钥别名形式的 ARN，例如 ` arn:aws:kms:region:account-id:alias/alias-name `。
**重要**
如果选择此选项，则创建或更新连接的任何用户或角色必须对指定的 KMS 密钥具有 `kms:Encrypt` 权限。
有关更多信息，请参阅 [加密连接密码](encrypt-connection-passwords.md)。
1. 选择 **Settings (设置)**，然后在 **Permissions (权限)** 编辑器中添加策略声明来为您的账户更改数据目录的精细访问控制。一次只能将一个策略附加到数据目录。您可以将 JSON 资源策略粘贴到此控件中。有关更多信息，请参阅 [AWS Glue 内基于资源的策略](security_iam_service-with-iam.md#security_iam_service-with-iam-resource-based-policies)。
1. 选择 **Save (保存)**，以用您所做的任何更改更新您的数据目录。
您还可以使用 AWS Glue API 操作来放置、获取和删除资源策略。有关更多信息，请参阅 [AWS Glue 中的安全性 API](aws-glue-api-jobs-security.md)。