# 使用爬网程序填充 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 (查看分区)**，您可以看到为数据创建的分区。第一列将作为分区键。