

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 数据来源连接器
<a name="data-sources"></a>

本节介绍如何使用 Amazon Kendra 和 Amazon Kendra 连接到支持的数据库和数据源存储库 Amazon Kendra APIs。 AWS 管理控制台 

**Topics**
+ [数据来源模板架构](ds-schemas.md)
+ [Adobe Experience Manager](data-source-aem.md)
+ [Alfresco](data-source-alfresco.md)
+ [Aurora(MySQL)](data-source-aurora-mysql.md)
+ [Aurora(PostgreSQL)](data-source-aurora-postgresql.md)
+ [Amazon FSx（视窗）](data-source-fsx.md)
+ [Amazon FSx（NetApp ONTAP）](data-source-fsx-ontap.md)
+ [Amazon RDS/Aurora](data-source-database.md)
+ [Amazon RDS（微软 SQL Server）](data-source-rds-ms-sql-server.md)
+ [Amazon RDS(MySQL)](data-source-rds-mysql.md)
+ [Amazon RDS(Oracle)](data-source-rds-oracle.md)
+ [Amazon RDS(PostgreSQL)](data-source-rds-postgresql.md)
+ [Amazon S3](data-source-s3.md)
+ [Amazon Kendra 网络爬虫](data-source-web-crawler.md)
+ [Box](data-source-box.md)
+ [Confluence](data-source-confluence.md)
+ [自定义数据来源连接器](data-source-custom.md)
+ [Dropbox](data-source-dropbox.md)
+ [Drupal](data-source-drupal.md)
+ [GitHub](data-source-github.md)
+ [Gmail](data-source-gmail.md)
+ [Google Drive](data-source-google-drive.md)
+ [IBM DB2](data-source-ibm-db2.md)
+ [Jira](data-source-jira.md)
+ [Microsoft Exchange](data-source-exchange.md)
+ [微软 OneDrive](data-source-onedrive.md)
+ [微软 SharePoint](data-source-sharepoint.md)
+ [Microsoft SQL Server](data-source-ms-sql-server.md)
+ [Microsoft Teams](data-source-teams.md)
+ [Micoft Yammer](data-source-yammer.md)
+ [MySQL](data-source-mysql.md)
+ [Oracle Database](data-source-oracle-database.md)
+ [PostgreSQL](data-source-postgresql.md)
+ [Quip](data-source-quip.md)
+ [Salesforce](data-source-salesforce.md)
+ [ServiceNow](data-source-servicenow.md)
+ [Slack](data-source-slack.md)
+ [Zendesk](data-source-zendesk.md)

# 数据来源模板架构
<a name="ds-schemas"></a>

以下是支持模板的数据来源的模板架构。

**Topics**
+ [Adobe Experience Manager 模板架构](#ds-aem-schema)
+ [Amazon FSx (Windows) 模板架构](#ds-fsx-windows-schema)
+ [Amazon FSx (NetApp ONTAP) 模板架构](#ds-fsx-ontap-schema)
+ [Alfresco 模板架构](#ds-alfresco-schema)
+ [Aurora (MySQL) 模板架构](#ds-aurora-mysql-schema)
+ [Aurora (PostgreSQL) 模板架构](#ds-aurora-postgresql-schema)
+ [Amazon RDS （微软 SQL Server）模板架构](#ds-rds-ms-sql-server-schema)
+ [Amazon RDS (MySQL) 模板架构](#ds-rds-mysql-schema)
+ [Amazon RDS (甲骨文) 模板架构](#ds-rds-oracle-schema)
+ [Amazon RDS (PostgreSQL) 模板架构](#ds-rds-postgresql-schema)
+ [Amazon S3 模板架构](#ds-s3-schema)
+ [Amazon Kendra Web Crawler 模板架构](#ds-schema-web-crawler)
+ [Confluence 模板架构](#ds-confluence-schema)
+ [Dropbox 模板架构](#ds-dropbox-schema)
+ [Drupal 模板架构](#ds-drupal-schema)
+ [GitHub 模板架构](#ds-github-schema)
+ [Gmail 模板架构](#ds-gmail-schema)
+ [Google Drive 模板架构](#ds-googledrive-schema)
+ [IBM DB2 模板架构](#ds-ibm-db2-schema)
+ [Microsoft Exchange 模板架构](#ds-msexchange-schema)
+ [微软 OneDrive 模板架构](#ds-onedrive-schema)
+ [微软 SharePoint 模板架构](#ds-schema-sharepoint)
+ [Microsoft SQL Server 模板架构](#ds-ms-sql-server-schema)
+ [Microsoft Teams 模板架构](#ds-msteams-schema)
+ [Microsoft Yammer 模板架构](#ds-schema-yammer)
+ [MySQL 模板架构](#ds-mysql-schema)
+ [Oracle Database 模板架构](#ds-oracle-database-schema)
+ [PostgreSQL 模板架构](#ds-postgresql-schema)
+ [Salesforce 模板架构](#ds-salesforce-schema)
+ [ServiceNow 模板架构](#ds-servicenow-schema)
+ [Slack 模板架构](#ds-schema-slack)
+ [Zendesk 模板架构](#ds-schema-zendesk)

## Adobe Experience Manager 模板架构
<a name="ds-aem-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) 对象的一部分。在连接配置或存储库端点详细信息中，您需要提供 Adobe Experience Manager 主机 URL、身份验证类型，以及您是使用 Adobe Experience Manager（AEM）即云服务还是 AEM On-Premise。此外，请将数据来源的类型指定为 `AEM`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。有关更多信息，请参阅 [Adobe Experience Manager JSON 架构](#aem-json)。

下表描述 AEM JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| aemUrl | Adobe Experience Manager 主机 URL。例如，如果您使用 AEM On-Premise，则需要包含主机名和端口：https://hostname:port。或者，如果您使用 AEM 即云服务，则可以使用作者 URL：https://author-xxxxxx-xxxxxxx.adobeaemcloud.com。 | 
| authType | 您使用的身份验证类型，可以是 Basic 或 OAuth2。 | 
| deploymentType | 您使用的 Adobe Experience Manager 的类型，可以是 CLOUD 或 ON\$1PREMISE。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将Adobe Experience Manager页面和资产的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| timeZoneId |  如果您使用 AEM 本地部署，并且服务器的时区与 AEM 连接器或索引的时区不同，则可以指定与 Amazon Kendra AEM 连接器或索引对齐的服务器时区。 AEM 本地部署的默认时区是 AE Amazon Kendra M 连接器或索引的时区。AEM 即云服务的默认时区是格林威治标准时间。  | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 页面和资产的根路径列表。例如，页面的根路径可以是 /content/sub，而资源的根路径可以是 /1。content/sub/asset | 
| crawlAssets | 为 true 则爬取资产。 | 
| crawlPages | 为 true 则爬取页面。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Adobe Experience Manager 数据来源中包含某些特定页面和资源的正则表达式模式的列表。与模式匹配的页面和资产将包含在索引中。与模式不匹配的页面和资产将从索引中排除。如果页面或资产同时匹配包含和排除模式，则排除模式优先，也就是说，内容不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Adobe Experience Manager 数据来源中排除某些特定页面和资源的正则表达式模式的列表。与模式匹配的页面和资产将从索引中排除。与模式不匹配的页面和资产将包含在索引中。如果页面或资产同时匹配包含和排除模式，则排除模式优先，也就是说，内容不会包含在索引中。 | 
| pageComponents | 您想要编入索引的特定页面组件的名称的列表。 | 
| contentFragmentVariations | 您想要编入索引的 Adobe Experience Manager 内容片段的特定已保存变体的名称列表。 | 
| 类型 | 数据来源的类型。指定 AEM 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | 包含连接到 Adobe Experience Man AWS Secrets Manager ager 所需的键值对的密钥的亚马逊资源名称 (ARN)。有关这些键值对的信息，请参阅 [Connection instructions for Adobe Experience Manager](https://docs.aws.amazon.com/kendra/latest/dg/data-source-aem.html#data-source-procedure-aem)。 | 
| 版本 | 当前支持的此模板的版本。 | 

### Adobe Experience Manager JSON 架构
<a name="aem-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties":
  {
    "connectionConfiguration": {
      "type": "object",
      "properties":
      {
        "repositoryEndpointMetadata":
        {
          "type": "object",
          "properties":
          {
            "aemUrl":
            {
              "type": "string",
              "pattern": "https:.*"
            },
            "authType": {
              "type": "string",
              "enum": ["Basic", "OAuth2"]
            },
            "deploymentType": {
              "type": "string",
              "enum": ["CLOUD","ON_PREMISE"]
            }
          },
          "required":
          [
            "aemUrl",
            "authType",
            "deploymentType"
          ]
        }
      },
      "required":
      [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties":
      {
        "page":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "asset":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        }
      }
    },
    "additionalProperties": {
      "type": "object",
      "properties":
      {
        "timeZoneId": {
          "type": "string",
          "enum": [
            "Africa/Abidjan",
            "Africa/Accra",
            "Africa/Addis_Ababa",
            "Africa/Algiers",
            "Africa/Asmara",
            "Africa/Asmera",
            "Africa/Bamako",
            "Africa/Bangui",
            "Africa/Banjul",
            "Africa/Bissau",
            "Africa/Blantyre",
            "Africa/Brazzaville",
            "Africa/Bujumbura",
            "Africa/Cairo",
            "Africa/Casablanca",
            "Africa/Ceuta",
            "Africa/Conakry",
            "Africa/Dakar",
            "Africa/Dar_es_Salaam",
            "Africa/Djibouti",
            "Africa/Douala",
            "Africa/El_Aaiun",
            "Africa/Freetown",
            "Africa/Gaborone",
            "Africa/Harare",
            "Africa/Johannesburg",
            "Africa/Juba",
            "Africa/Kampala",
            "Africa/Khartoum",
            "Africa/Kigali",
            "Africa/Kinshasa",
            "Africa/Lagos",
            "Africa/Libreville",
            "Africa/Lome",
            "Africa/Luanda",
            "Africa/Lubumbashi",
            "Africa/Lusaka",
            "Africa/Malabo",
            "Africa/Maputo",
            "Africa/Maseru",
            "Africa/Mbabane",
            "Africa/Mogadishu",
            "Africa/Monrovia",
            "Africa/Nairobi",
            "Africa/Ndjamena",
            "Africa/Niamey",
            "Africa/Nouakchott",
            "Africa/Ouagadougou",
            "Africa/Porto-Novo",
            "Africa/Sao_Tome",
            "Africa/Timbuktu",
            "Africa/Tripoli",
            "Africa/Tunis",
            "Africa/Windhoek",
            "America/Adak",
            "America/Anchorage",
            "America/Anguilla",
            "America/Antigua",
            "America/Araguaina",
            "America/Argentina/Buenos_Aires",
            "America/Argentina/Catamarca",
            "America/Argentina/ComodRivadavia",
            "America/Argentina/Cordoba",
            "America/Argentina/Jujuy",
            "America/Argentina/La_Rioja",
            "America/Argentina/Mendoza",
            "America/Argentina/Rio_Gallegos",
            "America/Argentina/Salta",
            "America/Argentina/San_Juan",
            "America/Argentina/San_Luis",
            "America/Argentina/Tucuman",
            "America/Argentina/Ushuaia",
            "America/Aruba",
            "America/Asuncion",
            "America/Atikokan",
            "America/Atka",
            "America/Bahia",
            "America/Bahia_Banderas",
            "America/Barbados",
            "America/Belem",
            "America/Belize",
            "America/Blanc-Sablon",
            "America/Boa_Vista",
            "America/Bogota",
            "America/Boise",
            "America/Buenos_Aires",
            "America/Cambridge_Bay",
            "America/Campo_Grande",
            "America/Cancun",
            "America/Caracas",
            "America/Catamarca",
            "America/Cayenne",
            "America/Cayman",
            "America/Chicago",
            "America/Chihuahua",
            "America/Ciudad_Juarez",
            "America/Coral_Harbour",
            "America/Cordoba",
            "America/Costa_Rica",
            "America/Creston",
            "America/Cuiaba",
            "America/Curacao",
            "America/Danmarkshavn",
            "America/Dawson",
            "America/Dawson_Creek",
            "America/Denver",
            "America/Detroit",
            "America/Dominica",
            "America/Edmonton",
            "America/Eirunepe",
            "America/El_Salvador",
            "America/Ensenada",
            "America/Fort_Nelson",
            "America/Fort_Wayne",
            "America/Fortaleza",
            "America/Glace_Bay",
            "America/Godthab",
            "America/Goose_Bay",
            "America/Grand_Turk",
            "America/Grenada",
            "America/Guadeloupe",
            "America/Guatemala",
            "America/Guayaquil",
            "America/Guyana",
            "America/Halifax",
            "America/Havana",
            "America/Hermosillo",
            "America/Indiana/Indianapolis",
            "America/Indiana/Knox",
            "America/Indiana/Marengo",
            "America/Indiana/Petersburg",
            "America/Indiana/Tell_City",
            "America/Indiana/Vevay",
            "America/Indiana/Vincennes",
            "America/Indiana/Winamac",
            "America/Indianapolis",
            "America/Inuvik",
            "America/Iqaluit",
            "America/Jamaica",
            "America/Jujuy",
            "America/Juneau",
            "America/Kentucky/Louisville",
            "America/Kentucky/Monticello",
            "America/Knox_IN",
            "America/Kralendijk",
            "America/La_Paz",
            "America/Lima",
            "America/Los_Angeles",
            "America/Louisville",
            "America/Lower_Princes",
            "America/Maceio",
            "America/Managua",
            "America/Manaus",
            "America/Marigot",
            "America/Martinique",
            "America/Matamoros",
            "America/Mazatlan",
            "America/Mendoza",
            "America/Menominee",
            "America/Merida",
            "America/Metlakatla",
            "America/Mexico_City",
            "America/Miquelon",
            "America/Moncton",
            "America/Monterrey",
            "America/Montevideo",
            "America/Montreal",
            "America/Montserrat",
            "America/Nassau",
            "America/New_York",
            "America/Nipigon",
            "America/Nome",
            "America/Noronha",
            "America/North_Dakota/Beulah",
            "America/North_Dakota/Center",
            "America/North_Dakota/New_Salem",
            "America/Nuuk",
            "America/Ojinaga",
            "America/Panama",
            "America/Pangnirtung",
            "America/Paramaribo",
            "America/Phoenix",
            "America/Port-au-Prince",
            "America/Port_of_Spain",
            "America/Porto_Acre",
            "America/Porto_Velho",
            "America/Puerto_Rico",
            "America/Punta_Arenas",
            "America/Rainy_River",
            "America/Rankin_Inlet",
            "America/Recife",
            "America/Regina",
            "America/Resolute",
            "America/Rio_Branco",
            "America/Rosario",
            "America/Santa_Isabel",
            "America/Santarem",
            "America/Santiago",
            "America/Santo_Domingo",
            "America/Sao_Paulo",
            "America/Scoresbysund",
            "America/Shiprock",
            "America/Sitka",
            "America/St_Barthelemy",
            "America/St_Johns",
            "America/St_Kitts",
            "America/St_Lucia",
            "America/St_Thomas",
            "America/St_Vincent",
            "America/Swift_Current",
            "America/Tegucigalpa",
            "America/Thule",
            "America/Thunder_Bay",
            "America/Tijuana",
            "America/Toronto",
            "America/Tortola",
            "America/Vancouver",
            "America/Virgin",
            "America/Whitehorse",
            "America/Winnipeg",
            "America/Yakutat",
            "America/Yellowknife",
            "Antarctica/Casey",
            "Antarctica/Davis",
            "Antarctica/DumontDUrville",
            "Antarctica/Macquarie",
            "Antarctica/Mawson",
            "Antarctica/McMurdo",
            "Antarctica/Palmer",
            "Antarctica/Rothera",
            "Antarctica/South_Pole",
            "Antarctica/Syowa",
            "Antarctica/Troll",
            "Antarctica/Vostok",
            "Arctic/Longyearbyen",
            "Asia/Aden",
            "Asia/Almaty",
            "Asia/Amman",
            "Asia/Anadyr",
            "Asia/Aqtau",
            "Asia/Aqtobe",
            "Asia/Ashgabat",
            "Asia/Ashkhabad",
            "Asia/Atyrau",
            "Asia/Baghdad",
            "Asia/Bahrain",
            "Asia/Baku",
            "Asia/Bangkok",
            "Asia/Barnaul",
            "Asia/Beirut",
            "Asia/Bishkek",
            "Asia/Brunei",
            "Asia/Calcutta",
            "Asia/Chita",
            "Asia/Choibalsan",
            "Asia/Chongqing",
            "Asia/Chungking",
            "Asia/Colombo",
            "Asia/Dacca",
            "Asia/Damascus",
            "Asia/Dhaka",
            "Asia/Dili",
            "Asia/Dubai",
            "Asia/Dushanbe",
            "Asia/Famagusta",
            "Asia/Gaza",
            "Asia/Harbin",
            "Asia/Hebron",
            "Asia/Ho_Chi_Minh",
            "Asia/Hong_Kong",
            "Asia/Hovd",
            "Asia/Irkutsk",
            "Asia/Istanbul",
            "Asia/Jakarta",
            "Asia/Jayapura",
            "Asia/Jerusalem",
            "Asia/Kabul",
            "Asia/Kamchatka",
            "Asia/Karachi",
            "Asia/Kashgar",
            "Asia/Kathmandu",
            "Asia/Katmandu",
            "Asia/Khandyga",
            "Asia/Kolkata",
            "Asia/Krasnoyarsk",
            "Asia/Kuala_Lumpur",
            "Asia/Kuching",
            "Asia/Kuwait",
            "Asia/Macao",
            "Asia/Macau",
            "Asia/Magadan",
            "Asia/Makassar",
            "Asia/Manila",
            "Asia/Muscat",
            "Asia/Nicosia",
            "Asia/Novokuznetsk",
            "Asia/Novosibirsk",
            "Asia/Omsk",
            "Asia/Oral",
            "Asia/Phnom_Penh",
            "Asia/Pontianak",
            "Asia/Pyongyang",
            "Asia/Qatar",
            "Asia/Qostanay",
            "Asia/Qyzylorda",
            "Asia/Rangoon",
            "Asia/Riyadh",
            "Asia/Saigon",
            "Asia/Sakhalin",
            "Asia/Samarkand",
            "Asia/Seoul",
            "Asia/Shanghai",
            "Asia/Singapore",
            "Asia/Srednekolymsk",
            "Asia/Taipei",
            "Asia/Tashkent",
            "Asia/Tbilisi",
            "Asia/Tehran",
            "Asia/Tel_Aviv",
            "Asia/Thimbu",
            "Asia/Thimphu",
            "Asia/Tokyo",
            "Asia/Tomsk",
            "Asia/Ujung_Pandang",
            "Asia/Ulaanbaatar",
            "Asia/Ulan_Bator",
            "Asia/Urumqi",
            "Asia/Ust-Nera",
            "Asia/Vientiane",
            "Asia/Vladivostok",
            "Asia/Yakutsk",
            "Asia/Yangon",
            "Asia/Yekaterinburg",
            "Asia/Yerevan",
            "Atlantic/Azores",
            "Atlantic/Bermuda",
            "Atlantic/Canary",
            "Atlantic/Cape_Verde",
            "Atlantic/Faeroe",
            "Atlantic/Faroe",
            "Atlantic/Jan_Mayen",
            "Atlantic/Madeira",
            "Atlantic/Reykjavik",
            "Atlantic/South_Georgia",
            "Atlantic/St_Helena",
            "Atlantic/Stanley",
            "Australia/ACT",
            "Australia/Adelaide",
            "Australia/Brisbane",
            "Australia/Broken_Hill",
            "Australia/Canberra",
            "Australia/Currie",
            "Australia/Darwin",
            "Australia/Eucla",
            "Australia/Hobart",
            "Australia/LHI",
            "Australia/Lindeman",
            "Australia/Lord_Howe",
            "Australia/Melbourne",
            "Australia/NSW",
            "Australia/North",
            "Australia/Perth",
            "Australia/Queensland",
            "Australia/South",
            "Australia/Sydney",
            "Australia/Tasmania",
            "Australia/Victoria",
            "Australia/West",
            "Australia/Yancowinna",
            "Brazil/Acre",
            "Brazil/DeNoronha",
            "Brazil/East",
            "Brazil/West",
            "CET",
            "CST6CDT",
            "Canada/Atlantic",
            "Canada/Central",
            "Canada/Eastern",
            "Canada/Mountain",
            "Canada/Newfoundland",
            "Canada/Pacific",
            "Canada/Saskatchewan",
            "Canada/Yukon",
            "Chile/Continental",
            "Chile/EasterIsland",
            "Cuba",
            "EET",
            "EST5EDT",
            "Egypt",
            "Eire",
            "Etc/GMT",
            "Etc/GMT+0",
            "Etc/GMT+1",
            "Etc/GMT+10",
            "Etc/GMT+11",
            "Etc/GMT+12",
            "Etc/GMT+2",
            "Etc/GMT+3",
            "Etc/GMT+4",
            "Etc/GMT+5",
            "Etc/GMT+6",
            "Etc/GMT+7",
            "Etc/GMT+8",
            "Etc/GMT+9",
            "Etc/GMT-0",
            "Etc/GMT-1",
            "Etc/GMT-10",
            "Etc/GMT-11",
            "Etc/GMT-12",
            "Etc/GMT-13",
            "Etc/GMT-14",
            "Etc/GMT-2",
            "Etc/GMT-3",
            "Etc/GMT-4",
            "Etc/GMT-5",
            "Etc/GMT-6",
            "Etc/GMT-7",
            "Etc/GMT-8",
            "Etc/GMT-9",
            "Etc/GMT0",
            "Etc/Greenwich",
            "Etc/UCT",
            "Etc/UTC",
            "Etc/Universal",
            "Etc/Zulu",
            "Europe/Amsterdam",
            "Europe/Andorra",
            "Europe/Astrakhan",
            "Europe/Athens",
            "Europe/Belfast",
            "Europe/Belgrade",
            "Europe/Berlin",
            "Europe/Bratislava",
            "Europe/Brussels",
            "Europe/Bucharest",
            "Europe/Budapest",
            "Europe/Busingen",
            "Europe/Chisinau",
            "Europe/Copenhagen",
            "Europe/Dublin",
            "Europe/Gibraltar",
            "Europe/Guernsey",
            "Europe/Helsinki",
            "Europe/Isle_of_Man",
            "Europe/Istanbul",
            "Europe/Jersey",
            "Europe/Kaliningrad",
            "Europe/Kiev",
            "Europe/Kirov",
            "Europe/Kyiv",
            "Europe/Lisbon",
            "Europe/Ljubljana",
            "Europe/London",
            "Europe/Luxembourg",
            "Europe/Madrid",
            "Europe/Malta",
            "Europe/Mariehamn",
            "Europe/Minsk",
            "Europe/Monaco",
            "Europe/Moscow",
            "Europe/Nicosia",
            "Europe/Oslo",
            "Europe/Paris",
            "Europe/Podgorica",
            "Europe/Prague",
            "Europe/Riga",
            "Europe/Rome",
            "Europe/Samara",
            "Europe/San_Marino",
            "Europe/Sarajevo",
            "Europe/Saratov",
            "Europe/Simferopol",
            "Europe/Skopje",
            "Europe/Sofia",
            "Europe/Stockholm",
            "Europe/Tallinn",
            "Europe/Tirane",
            "Europe/Tiraspol",
            "Europe/Ulyanovsk",
            "Europe/Uzhgorod",
            "Europe/Vaduz",
            "Europe/Vatican",
            "Europe/Vienna",
            "Europe/Vilnius",
            "Europe/Volgograd",
            "Europe/Warsaw",
            "Europe/Zagreb",
            "Europe/Zaporozhye",
            "Europe/Zurich",
            "GB",
            "GB-Eire",
            "GMT",
            "GMT0",
            "Greenwich",
            "Hongkong",
            "Iceland",
            "Indian/Antananarivo",
            "Indian/Chagos",
            "Indian/Christmas",
            "Indian/Cocos",
            "Indian/Comoro",
            "Indian/Kerguelen",
            "Indian/Mahe",
            "Indian/Maldives",
            "Indian/Mauritius",
            "Indian/Mayotte",
            "Indian/Reunion",
            "Iran",
            "Israel",
            "Jamaica",
            "Japan",
            "Kwajalein",
            "Libya",
            "MET",
            "MST7MDT",
            "Mexico/BajaNorte",
            "Mexico/BajaSur",
            "Mexico/General",
            "NZ",
            "NZ-CHAT",
            "Navajo",
            "PRC",
            "PST8PDT",
            "Pacific/Apia",
            "Pacific/Auckland",
            "Pacific/Bougainville",
            "Pacific/Chatham",
            "Pacific/Chuuk",
            "Pacific/Easter",
            "Pacific/Efate",
            "Pacific/Enderbury",
            "Pacific/Fakaofo",
            "Pacific/Fiji",
            "Pacific/Funafuti",
            "Pacific/Galapagos",
            "Pacific/Gambier",
            "Pacific/Guadalcanal",
            "Pacific/Guam",
            "Pacific/Honolulu",
            "Pacific/Johnston",
            "Pacific/Kanton",
            "Pacific/Kiritimati",
            "Pacific/Kosrae",
            "Pacific/Kwajalein",
            "Pacific/Majuro",
            "Pacific/Marquesas",
            "Pacific/Midway",
            "Pacific/Nauru",
            "Pacific/Niue",
            "Pacific/Norfolk",
            "Pacific/Noumea",
            "Pacific/Pago_Pago",
            "Pacific/Palau",
            "Pacific/Pitcairn",
            "Pacific/Pohnpei",
            "Pacific/Ponape",
            "Pacific/Port_Moresby",
            "Pacific/Rarotonga",
            "Pacific/Saipan",
            "Pacific/Samoa",
            "Pacific/Tahiti",
            "Pacific/Tarawa",
            "Pacific/Tongatapu",
            "Pacific/Truk",
            "Pacific/Wake",
            "Pacific/Wallis",
            "Pacific/Yap",
            "Poland",
            "Portugal",
            "ROK",
            "Singapore",
            "SystemV/AST4",
            "SystemV/AST4ADT",
            "SystemV/CST6",
            "SystemV/CST6CDT",
            "SystemV/EST5",
            "SystemV/EST5EDT",
            "SystemV/HST10",
            "SystemV/MST7",
            "SystemV/MST7MDT",
            "SystemV/PST8",
            "SystemV/PST8PDT",
            "SystemV/YST9",
            "SystemV/YST9YDT",
            "Turkey",
            "UCT",
            "US/Alaska",
            "US/Aleutian",
            "US/Arizona",
            "US/Central",
            "US/East-Indiana",
            "US/Eastern",
            "US/Hawaii",
            "US/Indiana-Starke",
            "US/Michigan",
            "US/Mountain",
            "US/Pacific",
            "US/Samoa",
            "UTC",
            "Universal",
            "W-SU",
            "WET",
            "Zulu",
            "EST",
            "HST",
            "MST",
            "ACT",
            "AET",
            "AGT",
            "ART",
            "AST",
            "BET",
            "BST",
            "CAT",
            "CNT",
            "CST",
            "CTT",
            "EAT",
            "ECT",
            "IET",
            "IST",
            "JST",
            "MIT",
            "NET",
            "NST",
            "PLT",
            "PNT",
            "PRT",
            "PST",
            "SST",
            "VST"
          ]
        },
        "pageRootPaths":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "assetRootPaths":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "crawlAssets":
        {
          "type": "boolean"
        },
        "crawlPages":
        {
          "type": "boolean"
        },
        "pagePathInclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "pagePathExclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "pageNameInclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "pageNameExclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "assetPathInclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "assetPathExclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "assetTypeInclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "assetTypeExclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "assetNameInclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "assetNameExclusionPatterns":
        {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "pageComponents": {
          "type": "array",
          "items": {
            "type": "object"
            }
        },
        "contentFragmentVariations": {
          "type": "array",
          "items": {
            "type": "object"
          }
        },
        "cugExemptedPrincipals": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "required":
      []
    },
    "type": {
      "type": "string",
      "pattern": "AEM"
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## Amazon FSx (Windows) 模板架构
<a name="ds-fsx-windows-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以将文件系统 ID 作为连接配置或存储库端点详细信息的一部分提供。另外，您必须将数据来源的类型指定为 `FSX`，指定用作身份验证凭证的密钥以及其他必要的配置。然后，当您 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Amazon FSx (Windows) JSON 架构](#fsx-windows-json)。

下表描述了 Amazon FSx (Windows) JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| fileSystemId |  Amazon FSx 文件系统的标识符。您可以在控制台的 “文件系统” Amazon FSx 控制面板上找到您的文件系统 ID。 | 
| fileSystemType |  Amazon FSx 文件系统类型。要使用 Windows File Server 作为您的文件系统类型，请指定 WINDOWS。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
| 全部 | 将 Amazon FSx 数据源中文件的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| isCrawlAcl | true，如果您有访问控制列表（ACL）并想将其用于访问控制，则爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。 | 
| inclusionPatterns | 用于在 Amazon FSx 数据源中包含某些文件的正则表达式模式列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| exclusionPatterns | 用于排除 Amazon FSx 数据源中某些文件的正则表达式模式列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| 类型 | 数据来源的类型。对于 Windows 文件系统数据来源，请指定 FSX。 | 

### Amazon FSx (Windows) JSON 架构
<a name="fsx-windows-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "fileSystemId": {
              "type": "string",
              "pattern": "fs-.*"
            },
            "fileSystemType": {
              "type": "string",
              "pattern": "WINDOWS"
            }
          },
          "required": ["fileSystemId", "fileSystemType"]
        }
      }
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "All": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "STRING_LIST", "DATE"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": ["fieldMappings"]
        }
      },
      "required": ["All"]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "isCrawlAcl": {
          "type": "boolean"
        },
        "exclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "required": []
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL"
      ]
    },
    "type" : {
      "type" : "string",
      "pattern": "FSX"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "enableIdentityCrawler",
    "additionalProperties",
    "type"
  ]
}
```

## Amazon FSx (NetApp ONTAP) 模板架构
<a name="ds-fsx-ontap-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以将文件系统 ID 和存储虚拟机（SVM）作为连接配置或存储库端点详细信息的一部分提供。另外，您必须将数据来源的类型指定为 `FSXONTAP`，指定用作身份验证凭证的密钥以及其他必要的配置。然后，当您 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Amazon FSx (NetApp ONTAP) JSON 架构](#fsx-ontap-json)。

下表描述了 Amazon FSx (NetApp ONTAP) JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| fileSystemId |  Amazon FSx 文件系统的标识符。您可以在控制台的 “文件系统” Amazon FSx 控制面板上找到您的文件系统 ID。有关如何在 Amazon FSx 控制台中为 NetApp ONTAP 创建文件系统的信息，请参阅《FSx for ONTAP 用户[指南》中的 NetApp ONTAP 入门](https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/getting-started.html)指南。 | 
| fileSystemType |  Amazon FSx 文件系统类型。要使用 NetApp ONTAP 作为您的文件系统类型，请指定 ONTAP。 | 
| svmId | 用于您的适用于 NetApp ONTAP 的 Amazon FSx 文件系统的存储虚拟机（SVM）ID。要找到您的 SVM ID，请前往控制台中的 “文件系统” Amazon FSx 控制面板，选择您的文件系统 ID，然后选择 “存储虚拟机”。有关如何在 Amazon FSx 控制台中为创建文件系统的信息NetApp ONTAP，请参阅《FSx for ONTAP 用户[指南》中的 NetApp ONTAP 入门](https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/getting-started.html)指南。 | 
| protocolType | 无论您选择适用于 Windows 的通用互联网文件系统（CIFS）协议，还是选择适用于 Linux 的网络文件系统（NFS）协议。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
| 文件 | 将 Amazon FSx 数据源中文件的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。您的文件自定义元数据中必须有数据来源字段名称。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| crawlAcl | true，如果您有访问控制列表（ACL）并想将其用于访问控制，则爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。 | 
| inclusionPatterns | 用于在 Amazon FSx 数据源中包含某些文件的正则表达式模式列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| exclusionPatterns | 用于排除 Amazon FSx 数据源中某些文件的正则表达式模式列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| 类型 | 数据来源的类型。对于 NetApp ONTAP 文件系统数据来源，请指定 FSXONTAP。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn |  包含连接到您的文件系统所需的键值对的 AWS Secrets Manager 密钥的 Amazon 资源名称 (ARN)。 Amazon FSx 密钥必须包含具有以下键的 JSON 结构： <pre>{<br />    "username": "user@corp.example.com",<br />    "password": "password"<br />}</pre> 如果您对 Amazon FSx 文件系统使用 NFS 协议，则密钥将存储在 JSON 结构中，其中包含以下密钥： <pre>{<br />    "leftId": "left ID",<br />    "rightId": "right ID",<br />    "preSharedKey": "pre-shared key"<br />}</pre>  | 

### Amazon FSx (NetApp ONTAP) JSON 架构
<a name="fsx-ontap-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "fileSystemId": {
              "type": "string",
                "pattern": "^(fs-[0-9a-f]{8,21})$"
            },
            "fileSystemType": {
              "type": "string",
              "enum": ["ONTAP"]
            },
            "svmId": {
              "type": "string",
              "pattern": "^(svm-[0-9a-f]{17,21})$"
            },
            "protocolType": {
              "type": "string",
              "enum": [
                "CIFS",
                "NFS"
              ]
            }
          },
          "required": [
            "fileSystemId",
            "fileSystemType"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "file": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string",
                      "pattern": "^([a-zA-Z_]{1,20})$"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string",
                      "pattern": "^([a-zA-Z_]{1,20})$"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ],
              "maxItems": 50
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
        "file"
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "crawlAcl": {
          "type": "boolean"
        },
        "inclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 30
          },
          "maxItems": 100
        },
        "exclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 30
          },
          "maxItems": 100
        }
      }
    },
    "type": {
      "type": "string",
      "pattern": "FSXONTAP"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL"
      ]
    },
    "secretArn": {
      "type": "string",
      "pattern": "arn:aws:secretsmanager:.*"
    }
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## Alfresco 模板架构
<a name="ds-alfresco-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) 对象的一部分。您需要提供 Alfresco 站点 ID、存储库 URL、用户界面 URL、身份验证类型，您是使用云还是本地部署，以及要爬取的内容类型。您可以将其作为连接配置或存储库端点详细信息的一部分提供。还要将数据来源的类型指定为 `ALFRESCO`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Alfresco JSON 架构](#alfresco-json)。

下表描述 Alfresco JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| siteId | Alfresco 站点的标识符。 | 
| repoUrl | 您的 Alfresco 存储库的 URL。您可以向 Alfresco 管理员获取存储库 URL。例如，如果您使用 Alfresco Cloud（PaaS），则存储库 URL 可能是 https://company.alfrescocloud.com。或者，如果您使用 Alfresco On-Premises，则存储库 URL 可能是 https://company-alfresco-instance.company-domain.suffix:port。 | 
| webAppUrl | 您的 Alfresco 用户界面的 URL。您可以向 Alfresco 管理员获取 Alfresco 用户界面 URL。例如，用户界面 URL 可能是 https://example.com。 | 
| repositoryAdditionalProperties | 用于连接 repository/data 源端点的其他属性。 | 
| authType | 您使用的身份验证类型，可以是 OAuth2 或 Basic。 | 
| type (deployment) | 您使用的 Alfresco 的类型，可以是 PAAS 或 ON-PREM。 | 
| crawlType | 您要爬取的内容类型，可以是 ASPECT（Alfresco 中标有“方面”的内容）、SITE\$1ID（特定 Alfresco 网站内的内容）或 ALL\$1SITES（所有 Alfresco 网站上的内容）。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将您的 Alfresco 文档和注释的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| aspectName |  要编制索引的特定“方面”的名称。  | 
| aspectProperties |  要编制索引的特定“方面”内容属性的列表。  | 
| enableFineGrained控件 |  如果为 `true`，要爬取“方面”。  | 
| isCrawlComment |  如果为 `true`，则爬取评论。  | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Alfresco 数据来源中包含某些文件的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Alfresco 数据来源中排除某些文件的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| 类型 | 数据来源的类型。指定 ALFRESCO 作为数据来源类型。 | 
| secretArn |   AWS Secrets Manager 密钥的 Amazon 资源名称 (ARN)，其中包含连接到您的所需的键值对。Alfresco密钥必须包含具有以下键的 JSON 结构： 如果使用基本身份验证： <pre>{<br />    "username": "user name",<br />    "password": "password"<br />}</pre> 如果使用 OAuth 2.0 身份验证： <pre>{<br />    "clientId": "client ID",<br />    "clientSecret": "client secret",<br />    "tokenUrl": "token URL"<br />}</pre>  | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| 版本 | 当前支持的此模板的版本。 | 

### Alfresco JSON 架构
<a name="alfresco-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "siteId": {
              "type": "string"
            },
            "repoUrl": {
              "type": "string"
            },
            "webAppUrl": {
              "type": "string"
            },
            "repositoryAdditionalProperties": {
              "type": "object",
              "properties": {
                "authType": {
                  "type": "string",
                  "enum": [
                    "OAuth2",
                    "Basic"
                  ]
                },
                "type": {
                  "type": "string",
                  "enum": [
                    "PAAS",
                    "ON_PREM"
                  ]
                },
                "crawlType": {
                  "type": "string",
                  "enum": [
                    "ASPECT",
                    "SITE_ID",
                    "ALL_SITES"
                  ]
                }
              }
            }
          }
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "DATE",
                          "STRING_LIST",
                          "LONG"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "comment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "DATE",
                          "STRING_LIST",
                          "LONG"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "aspectName": {
          "type": "string"
        },
        "aspectProperties": {
          "type": "array"
        },
        "enableFineGrainedControl": {
          "type": "boolean"
        },
        "isCrawlComment": {
          "type": "boolean"
        },
        "inclusionFileNamePatterns": {
          "type": "array"
        },
        "exclusionFileNamePatterns": {
          "type": "array"
        },
        "inclusionFileTypePatterns": {
          "type": "array"
        },
        "exclusionFileTypePatterns": {
          "type": "array"
        },
        "inclusionFilePathPatterns": {
          "type": "array"
        },
        "exclusionFilePathPatterns": {
          "type": "array"
        }
      }
    },
    "type": {
      "type": "string",
      "pattern": "ALFRESCO"
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL"
      ]
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "version": {
      "type": "string",
      "anyOf": [
        {
          "pattern": "1.0.0"
        }
      ]
    }
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "additionalProperties",
    "type",
    "secretArn"
  ]
}
```

## Aurora (MySQL) 模板架构
<a name="ds-aurora-mysql-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`mysql` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Aurora (MySQL) JSON 架构](#aurora-mysql-json)。

下表描述了 Aurora (MySQL) JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Aurora (MySQL) JSON 架构
<a name="aurora-mysql-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Aurora (PostgreSQL) 模板架构
<a name="ds-aurora-postgresql-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`postgresql` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Aurora (PostgreSQL) JSON 架构](#aurora-postgresql-json)。

下表描述了 (PostgreSQL Aurora ) JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Aurora (PostgreSQL) JSON 架构
<a name="aurora-postgresql-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Amazon RDS （微软 SQL Server）模板架构
<a name="ds-rds-ms-sql-server-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`sqlserver` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Amazon RDS （微软 SQL Server）JSON 架构](#rds-ms-sql-server-json)。

下表描述了 Amazon RDS （微软 SQL Server）JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Amazon RDS （微软 SQL Server）JSON 架构
<a name="rds-ms-sql-server-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Amazon RDS (MySQL) 模板架构
<a name="ds-rds-mysql-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`mysql` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Amazon RDS (MySQL) JSON 架构](#rds-mysql-json)。

下表描述了 Amazon RDS (MySQL) JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Amazon RDS (MySQL) JSON 架构
<a name="rds-mysql-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Amazon RDS (甲骨文) 模板架构
<a name="ds-rds-oracle-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`oracle` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Amazon RDS (甲骨文) JSON 架构](#rds-oracle-json)。

下表描述了 Amazon RDS (Oracle) JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Amazon RDS (甲骨文) JSON 架构
<a name="rds-oracle-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Amazon RDS (PostgreSQL) 模板架构
<a name="ds-rds-postgresql-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`postgresql` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Amazon RDS (PostgreSQL) JSON 架构](#rds-postgresql-json)。

下表描述了 (PostgreSQL Amazon RDS ) JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Amazon RDS (PostgreSQL) JSON 架构
<a name="rds-postgresql-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Amazon S3 模板架构
<a name="ds-s3-schema"></a>

您可以将包含数据来源架构的 JSON 作为模板配对的一部分。您可以将其作为连接配置或存储库端点详细信息的一部分提供 S3 存储桶的名称。还要将数据来源的类型指定为 `S3`，以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[S3 JSON 架构](#s3-json)。

下表描述了 Amazon S3 JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| BucketName | 您的 Amazon S3 存储桶的名称。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
| additionalProperties | 数据来源中内容的其他配置选项 | 
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 用于在 Amazon S3 数据源中包含或排除特定文件的正则表达式模式列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| aclConfigurationFile路径 | 控制对 Amazon Kendra 索引中文档的访问权限的文件路径。 | 
| metadataFilesPrefix | 存储桶中存放元数据文件的位置。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| 类型 | 数据来源的类型。指定 S3 作为数据来源类型。 | 
| 版本 | 支持的模板的版本。 | 

### S3 JSON 架构
<a name="s3-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "BucketName": {
              "type": "string"
            }
          },
          "required": [
            "BucketName"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
        "document"
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "inclusionPatterns": {
          "type": "array"
        },
        "exclusionPatterns": {
          "type": "array"
        },
        "inclusionPrefixes": {
          "type": "array"
        },
        "exclusionPrefixes": {
          "type": "array"
        },
        "aclConfigurationFilePath": {
          "type": "string"
        },
        "metadataFilesPrefix": {
          "type": "string"
        }
      }
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FULL_CRAWL",
        "FORCED_FULL_CRAWL"
      ]
    },
    "type": {
      "type": "string",
      "pattern": "S3"
    },
    "version": {
      "type": "string",
      "anyOf": [
        {
          "pattern": "1.0.0"
        }
      ]
    }
  },
  "required": [
    "connectionConfiguration",
    "type",
    "syncMode",
    "repositoryConfigurations"
  ]
}
```

## Amazon Kendra Web Crawler 模板架构
<a name="ds-schema-web-crawler"></a>

您可以将包含数据来源架构的 JSON 作为 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) 对象的一部分。

您可以提供种子或起点 URLs，也可以提供站点地图 URLs，作为连接配置或存储库端点详细信息的一部分。您可以提供存储种子 URLs 或站点地图 XML 文件列表的文本文件的 Amazon S3 存储桶路径，您可以在 S3 中将这些文件组合成一个 ZIP 文件，而不必手动列出所有文件。 URLs

此外，您还要将数据来源的类型指定为 `WEBCRAWLERV2`，指定网站身份验证凭证和身份验证类型（如果您的网站需要身份验证）以及其他必要的配置。

然后，当您 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

**重要**  
不支持 Web Crawler v2.0 连接器的创建。 CloudFormation如果需要 CloudFormation 支持，请使用 Web Crawler v1.0 连接器。

*当选择要编制索引的网站时，您必须遵守 [Amazon 可接受使用政策](https://aws.amazon.com/aup/)以及所有其他 Amazon 条款。请记住，您只能使用 Amazon Kendra Web Crawler 来索引自己的网页或您有权编制索引的网页。要了解如何阻止 Amazon Kendra Web 爬网程序将您的网站编入索引，请参阅[为 Amazon Kendra Web Crawler 配置`robots.txt`文件](stop-web-crawler.md)。*

您可以使用本开发者指南中提供的模板。请参阅[Amazon Kendra 网络爬虫 JSON 架构](#web-crawler-json)。

下表描述了 Amazon Kendra Web Crawler JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| siteMapUrls | 您要抓 URLs 取的网站的站点地图列表。您最多可以列出三个站点地图 URLs。 | 
| s3 SeedUrl | 存储种子列表或起点列表的文本文件的 S3 路径 URLs。例如 s3://bucket-name/directory/。文本文件中的每个 URL 都必须对单行进行格式化。一个文件中最多可以列出 100 URLs 个种子。 | 
| s3 SiteMapUrl | 站点地图 XML 文件的 S3 路径。例如 s3://bucket-name/directory/。您最多可以列出三个站点地图 XML 文件。您可以将多个站点地图文件组合成一个 ZIP 文件，然后将 ZIP 文件存储在存储 Amazon S3 桶中。 | 
| seedUrlConnections | 您要抓取的网站的种子列表或起点 URLs 列表。您最多可以列出 100 个种子。 URLs | 
| seedUrl | 种子或起点 URL。 | 
| 身份验证 | 如果您的网站需要相同的身份验证，则为身份验证类型，否则指定 NoAuthentication。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将网页和网页文件的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。例如，HTML 网页标题标签可以映射到 \$1document\$1title 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| rateLimit | 每位网站主机每分钟的最大 URLs 抓取次数。 | 
| maxFileSize | 要爬取的网页或附件的最大大小（以 MB 为单位）。 | 
| crawlDepth | 从种子 URL 爬取的层数。例如，种子 URL 页面的深度为 1，在该页面上同时爬取的所有超链接的深度都是 2。 | 
| maxLinksPer网址 | 抓取网站时，网页 URLs 上要包含的最大数量。每个网页都有一个数字。当网站的网页被抓取时，网页链接到 URLs 的任何网页也会被抓取。 URLs 在网页上按出现顺序进行抓取。 | 
| crawlSubDomain | true，爬取包含子域的网站域。例如，如果种子 URL 是“abc.example.com”，则还会爬取“a.abc.example.com”和“b.abc.example.com”。如果您未设置crawlSubDomain或 crawlAllDomaintrue，则 Amazon Kendra 只会抓取您要抓取的网站的域名。 | 
| crawlAllDomain | true，爬取有子域的网站域和网页链接到的其他域。如果您未设置crawlSubDomain或 crawlAllDomaintrue，则 Amazon Kendra 只会抓取您要抓取的网站的域名。 | 
| honorRobots | true，遵循您想要爬取的网站的 robots.txt 指令。这些指令控制 Amazon Kendra Web Crawler 如何抓取网站，无论是 Amazon Kendra 只能抓取特定内容还是不能抓取任何内容。 | 
| crawlAttachments | true，爬取网页链接到的文件。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 正则表达式模式列表，包括抓取这些 URL 网页上的某些超链接 URLs 和索引任何超链接。 URLs 与模式相匹配的包含在索引中。 URLs 与模式不匹配的将被排除在索引之外。如果 URL 同时匹配包含和排除模式，则以排除模式为优先，并且该 URL/网站的网页不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 正则表达式模式列表，用于排除抓取这些 URL 网页上的某些超链接 URLs 和索引任何超链接。 URLs 与模式相匹配的将从索引中排除。 URLs 与模式不匹配的将包含在索引中。如果 URL 同时匹配包含和排除模式，则以排除模式为优先，并且该 URL/网站的网页不会包含在索引中。 | 
| inclusionFileIndex图案 | 正则表达式模式的列表，用于包含某些网页文件。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| exclusionFileIndex图案 | 正则表达式模式的列表，用于排除某些网页文件。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| implicitWaitDuration |  implicitWaitDuration 指定连接器在抓取网页之前将等待多长时间（以秒为单位）。 范围：0-10  例如。“implicitWaitDuration“: “5"  | 
| proxy | 通过 Web 代理连接到内部网站所需的配置信息。 | 
| host | 您想要通过用于连接内部网站的代理服务器的主机名。例如，https://a.example.com/page1.html 的主机名是“a.example.com”。 | 
| 端口 | 您想要用于连接内部网站的代理服务器的端口号。例如，443 是 HTTPS 的标准端口。 | 
| secretArn（代理） | 如果需要网络代理凭据才能连接到网站主机，则可以创建一个存储凭据的 AWS Secrets Manager 密钥。为密钥提供 Amazon 资源名称（ARN）。 | 
| 类型 | 数据来源的类型。指定 WEBCRAWLERV2 作为数据来源类型。 | 
| secretArn |  您的网站需要身份验证才能访问网站时使用的 AWS Secrets Manager 密钥的 Amazon 资源名称 (ARN)。网站的身份验证凭证存储在包含 JSON 键值对的密钥中。 如果您使用基本或 NTML/Kerberos 身份验证，请输入用户名和密码。密钥中的 JSON 键必须是 `userName` 和 `password`。NTLM 身份验证协议包括密码哈希，Kerberos 身份验证协议包括密码加密。 如果您使用 SAML 或表单身份验证，请 XPath为用户名字段（如果使用 SAML 则输入用户名按钮）、 XPaths 密码字段和按钮以及登录页面 URL 的用户名和密码。密钥中的 JSON 键必须是 `userName`、`password`、`userNameFieldXpath`、`userNameButtonXpath`、`passwordFieldXpath`、`passwordButtonXpath` 和 `loginPageUrl`。你可以使用 Web 浏览器的开发者工具找到元素的 XPaths （XML 路径语言）。 XPaths 通常遵循这种格式:`//tagname[@Attribute='Value']`. Amazon Kendra 还会检查密钥中包含的端点信息（种子 URLs）是否与数据源终端节点配置详细信息中指定的端点信息相同。  | 
| 版本 | 当前支持的此模板的版本。 | 

### Amazon Kendra 网络爬虫 JSON 架构
<a name="web-crawler-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "siteMapUrls": {
              "type": "array",
              "items":{
                "type": "string",
                "pattern": "https://.*"
              }
            },
            "s3SeedUrl": {
              "type": "string",
              "pattern": "s3:.*"
            },
            "s3SiteMapUrl": {
              "type": "string",
              "pattern": "s3:.*"
            },
            "seedUrlConnections": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "seedUrl":{
                      "type": "string",
                      "pattern": "https://.*"
                    }
                  },
                  "required": [
                    "seedUrl"
                  ]
                }
              ]
            },
            "authentication": {
              "type": "string",
              "enum": [
                "NoAuthentication",
                "BasicAuth",
                "NTLM_Kerberos",
                "Form",
                "SAML"
              ]
            }
          }
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "webPage": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "attachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL"
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "rateLimit": {
          "type": "string",
          "default": "300"
        },
        "maxFileSize": {
          "type": "string",
          "default": "50"
        },
        "crawlDepth": {
          "type": "string",
          "default": "2"
        },
        "maxLinksPerUrl": {
          "type": "string",
          "default": "100"
        },
        "crawlSubDomain": {
          "type": "boolean",
          "default": false
        },
        "crawlAllDomain": {
          "type": "boolean",
          "default": false
        },
        "honorRobots": {
          "type": "boolean",
          "default": false
        },
        "crawlAttachments": {
          "type": "boolean",
          "default": false
        },
        "inclusionURLCrawlPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionURLCrawlPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionURLIndexPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionURLIndexPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionFileIndexPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileIndexPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "proxy": {
          "type": "object",
          "properties": {
            "host": {
              "type": "string"
            },
            "port": {
              "type": "string"
            },
            "secretArn": {
              "type": "string",
              "minLength": 20,
              "maxLength": 2048
            }
          }
        }
      },
      "implicitWaitDuration":  {
          "type":"object",
          "properties": {
            "innerNumber" : {
              "type": "number",
              "minimum": 0,
              "maximum": 10
            }
          }
        },
      "required": [
        "rateLimit",
        "maxFileSize",
        "crawlDepth",
        "crawlSubDomain",
        "crawlAllDomain",
        "maxLinksPerUrl",
        "honorRobots"
      ]
    },
    "type": {
      "type": "string",
      "pattern": "WEBCRAWLERV2"
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "type",
    "additionalProperties"
  ]
}
```

## Confluence 模板架构
<a name="ds-confluence-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以在连接配置或存储库端点详细信息中提供 Confluence 主机 URL、托管方法和身份验证类型。还要将数据来源的类型指定为 `CONFLUENCEV2`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Confluence JSON 架构](#confluence-json)。

下表描述 Confluence JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| hostUrl | 您的 Confluence 实例的 URL。例如 https://example.confluence.com。 | 
| 类型 | 您的 Confluence 实例的托管方法，可以是 SAAS 和 ON\$1PREM。 | 
| authType | 您的 Confluence 实例的身份验证方法，可以是 Basic、OAuth2 或 Personal-token。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将您的 Confluence 空间、页面、博客、评论和附件的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。您的 Confluence 自定义元数据中必须有 Confluence 数据来源字段名称。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| isCrawlAcl | 如果您有访问控制列表（ACL）并想将其用于访问控制，则配置 true 以爬取文档的 ACL 信息。注意，ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。这意味着，如果 isCrawlACL 关闭，则可以公开搜索文档。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。 | 
| fieldForUser我是 | 如果要使用用户电子邮件作为用户 ID，则指定 email。默认使用 email，这是目前唯一支持的用户 ID 类型。 | 
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 包含在您的 Confluence 数据源中 and/or 排除某些文件的正则表达式模式列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| proxyHost | 您使用的 Web 代理的主机名，其中不包含 http:// 或 https:// 协议。 | 
|  proxyPort  | 主机 URL 传输协议使用的端口号。必须是介于 0 和 65535 之间的数值。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则爬取您的 Confluence 个人空间、页面、博客、页面评论、页面附件、博客评论和博客附件中的文件。 | 
| maxFileSizeInMegaBytes | 在中指定 Amazon Kendra 可以爬 MBs 行的文件大小限制。 Amazon Kendra 仅抓取您定义的大小限制内的文件。默认文件大小为 50 MB。最大文件大小应大于 0 MB 且小于或等于 50 MB。 | 
| 类型 | 数据来源的类型。指定 CONFLUENCEV2 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode | 指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretARN | 包含连接您的 Confluence 所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。有关这些键值对的信息，请参阅 [Connection instructions for Confluence](https://docs.aws.amazon.com/kendra/latest/dg/data-source-v2-confluence.html#data-source-procedure-v2-confluence)。 | 
| 版本 | 当前支持的此模板的版本。 | 

### Confluence JSON 架构
<a name="confluence-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "hostUrl": {
              "type": "string",
              "pattern": "https:.*"
            },
            "type": {
              "type": "string",
              "enum": [
                "SAAS",
                "ON_PREM"
              ]
            },
            "authType": {
              "type": "string",
              "enum": [
                "Basic",
                "OAuth2",
                "Personal-token"
              ]
            }
          },
          "required": [
            "hostUrl",
            "type",
            "authType"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "space": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "page": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "blog": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "comment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "attachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "usersAclS3FilePath": {
          "type": "string"
        },
        "isCrawlAcl": {
          "type": "boolean"
        },
        "fieldForUserId": {
          "type": "string"
        },
        "inclusionSpaceKeyFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionSpaceKeyFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "pageTitleRegEX": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "blogTitleRegEX": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "commentTitleRegEX": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "attachmentTitleRegEX": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "isCrawlPersonalSpace": {
          "type": "boolean"
        },
        "isCrawlArchivedSpace": {
          "type": "boolean"
        },
        "isCrawlArchivedPage": {
          "type": "boolean"
        },
        "isCrawlPage": {
          "type": "boolean"
        },
        "isCrawlBlog": {
          "type": "boolean"
        },
        "isCrawlPageComment": {
          "type": "boolean"
        },
        "isCrawlPageAttachment": {
          "type": "boolean"
        },
        "isCrawlBlogComment": {
          "type": "boolean"
        },
        "isCrawlBlogAttachment": {
          "type": "boolean"
        },
        "maxFileSizeInMegaBytes":  {
          "type":"string"
        },
        "inclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionUrlPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionUrlPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "proxyHost": {
          "type": "string"
        },
        "proxyPort": {
          "type": "string"
        }
      },
      "required": []
    },
    "type": {
      "type": "string",
      "pattern": "CONFLUENCEV2"
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FULL_CRAWL",
        "FORCED_FULL_CRAWL"
      ]
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## Dropbox 模板架构
<a name="ds-dropbox-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您提供 Dropbox 应用程序键、应用程序密钥和访问令牌作为存储身份验证凭证的密钥的一部分。还要将数据来源的类型指定为 `DROPBOX`、要使用的访问令牌的类型（临时或永久）以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Dropbox JSON 模式](#dropbox-json)。

下表描述 Dropbox JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。此数据来源未在 repositoryEndpointMetadata 中指定端点。相反，连接信息包含在您提供的 AWS Secrets Manager 密钥中secretArn。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 映射您的 Dropbox 文件、Dropbox Paper 的属性或字段名称的对象列表，以及 Amazon Kendra 索引字段名称的快捷方式。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| secretARN | 包含连接您的 Dropbox 所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "appKey": "Dropbox app key",<br />    "appSecret": "Dropbox app secret",<br />    "accesstoken": "temporary access token or refresh access token"<br />}</pre> | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| isCrawlAcl | true，如果您有访问控制列表（ACL）并想将其用于访问控制，则爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Dropbox 数据来源中包含某些文件名和类型的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Dropbox 数据来源中排除某些文件名和类型的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则爬取存储在 Dropbox 中的文件、Dropbox Paper 文档、Dropbox Paper 模板和网页快捷方式。 | 
| 类型 | 数据来源的类型。指定 DROPBOX 作为数据来源类型。 | 
| tokenType | 指定您的访问令牌类型：永久或临时访问令牌。建议您创建在 Dropbox 中永不过期的刷新访问令牌，而不是依赖在 4 小时后过期的一次性访问令牌。您可以在 Dropbox 开发者控制台中创建应用程序和刷新访问令牌，并在密钥中提供访问令牌。 | 
| 版本 | 当前支持的此模板的版本。 | 

### Dropbox JSON 模式
<a name="dropbox-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
          }
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "file": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "STRING_LIST",
                          "LONG",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "paper": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "STRING_LIST",
                          "LONG",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "papert": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "STRING_LIST",
                          "LONG",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "shortcut": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "STRING_LIST",
                          "LONG",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FULL_CRAWL",
        "FORCED_FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "secretArn": {
      "type": "string"
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "isCrawlAcl": {
          "type": "boolean"
        },
        "inclusionFileNamePatterns": {
          "type": "array"
        },
        "exclusionFileNamePatterns": {
          "type": "array"
        },
        "inclusionFileTypePatterns": {
          "type": "array"
        },
        "exclusionFileTypePatterns": {
          "type": "array"
        },
        "crawlFile": {
          "type": "boolean"
        },
        "crawlPaper": {
          "type": "boolean"
        },
        "crawlPapert": {
          "type": "boolean"
        },
        "crawlShortcut": {
          "type": "boolean"
        }
      }
    },
    "type": {
      "type": "string",
      "pattern": "DROPBOX"
    },
    "tokenType": {
      "type": "string",
      "enum": [
        "PERMANENT",
        "TEMPORARY"
      ]
    },
    "version": {
      "type": "string",
      "anyOf": [
        {
          "pattern": "1.0.0"
        }
      ]
    }
  },
  "additionalProperties": false,
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "additionalProperties",
    "syncMode",
    "enableIdentityCrawler",
    "secretArn",
    "type",
    "tokenType"
  ]
}
```

## Drupal 模板架构
<a name="ds-drupal-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) 对象的一部分。您可以在连接配置或存储库端点详细信息中提供 Drupal 主机 URL 和身份验证类型。还要将数据来源的类型指定为 DRUPAL、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Drupal JSON 架构](#drupal-json)。

下表描述 Drupal JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| hostUrl | 您的 Drupal 网站的主机 URL。例如 https://<hostname>/<drupalsitename>。 | 
| repositoryConfigurations | 数据来源内容的配置信息。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 映射 Drupal 文件的属性或字段名称的对象的列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。您的 Drupal 自定义元数据中必须有 Drupal 数据来源字段名称。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 用于在 Drupal 数据来源中包含某些文件的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 用于在 Drupal 数据来源中排除某些文件的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| contentDefinitions[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 指定要爬取的内容类型以及是否爬取所选内容类型的评论和附件。 | 
| 类型 | 数据来源的类型。指定 DRUPAL 作为数据来源类型。 | 
| authType | 您使用的身份验证类型，可以是 BASIC-AUTH 或 OAUTH2。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| secretARN | 包含连接您的 Drupal 所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。密钥必须包含具有以下键的 JSON 结构：**如果使用基本身份验证：**<pre>{<br />    "username": "user name",<br />    "passwords": "password"<br />}</pre> **如果使用 OAuth 2.0 身份验证：**<pre>{<br />    "username": "user name",<br />    "password": "password",<br />    "clientId": "client id",<br />    "clientSecret": "client secret"<br />}</pre>  | 
| 版本 | 当前支持的此模板的版本。 | 

### Drupal JSON 架构
<a name="drupal-json"></a>

```
{
	"$schema": "http://json-schema.org/draft-04/schema#",
	"type": "object",
	"properties": {
		"connectionConfiguration": {
			"type": "object",
			"properties": {
				"repositoryEndpointMetadata": {
					"type": "object",
					"properties": {
						"hostUrl": {
							"type": "string",
							"pattern": "https:.*"
						}
					},
					"required": [
						"hostUrl"
					]
				}
			},
			"required": [
				"repositoryEndpointMetadata"
			]
		},
		"repositoryConfigurations": {
			"type": "object",
			"properties": {
				"content": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"DATE"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				},
				"comment": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"DATE"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				},
				"attachment": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"DATE"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				}
			}
		},
		"additionalProperties": {
			"type": "object",
			"properties": {
				"isCrawlArticle": {
					"type": "boolean"
				},
				"isCrawlBasicPage": {
					"type": "boolean"
				},
				"isCrawlBasicBlock": {
					"type": "boolean"
				},
				"crawlCustomContentTypesList": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"crawlCustomBlockTypesList": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"filePath": {
					"anyOf": [
						{
							"type": "string",
							"pattern": "s3:.*"
						},
						{
							"type": "string",
							"pattern": ""
						}
					]
				},
				"inclusionFileNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionFileNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"articleTitleInclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"articleTitleExclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"pageTitleInclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"pageTitleExclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"customContentTitleInclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"customContentTitleExclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"basicBlockTitleInclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"basicBlockTitleExclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"customBlockTitleInclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"customBlockTitleExclusionPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"contentDefinitions": {
					"type": "array",
					"items": {
						"properties": {
							"contentType": {
								"type": "string"
							},
							"fieldDefinition": {
								"type": "array",
								"items": [
									{
										"type": "object",
										"properties": {
											"machineName": {
												"type": "string"
											},
											"type": {
												"type": "string"
											}
										},
										"required": [
											"machineName",
											"type"
										]
									}
								]
							},
							"isCrawlComments": {
								"type": "boolean"
							},
							"isCrawlFiles": {
								"type": "boolean"
							}
						}
					},
					"required": [
						"contentType",
						"fieldDefinition",
						"isCrawlComments",
						"isCrawlFiles"
					]
				}
			},
			"required": []
		},
		"type": {
			"type": "string",
			"pattern": "DRUPAL"
		},
		"authType": {
			"type": "string",
			"enum": [
				"BASIC-AUTH",
				"OAUTH2"
			]
		},
		"syncMode": {
			"type": "string",
			"enum": [
				"FORCED_FULL_CRAWL",
				"FULL_CRAWL",
				"CHANGE_LOG"
			]
		},
		"enableIdentityCrawler": {
			"type": "boolean"
		},
		"secretArn": {
			"type": "string",
			"minLength": 20,
			"maxLength": 2048
		}
	},
	"version": {
		"type": "string",
		"anyOf": [
			{
				"pattern": "1.0.0"
			}
		]
	},
	"required": [
		"connectionConfiguration",
		"repositoryConfigurations",
		"syncMode",
		"additionalProperties",
		"secretArn",
		"type"
	]
}
```

## GitHub 模板架构
<a name="ds-github-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) 对象的一部分。在连接配置或存储库终端节点详细信息中，您需要提供 GitHub 主机 URL、组织名称以及您是使用 GitHub 云端还是 GitHub 本地部署。还要将数据来源的类型指定为 `GITHUB`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[GitHub JSON 模式](#github-json)。

下表描述了 GitHub JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| 类型 | 指定类型 SAAS 或 ON\$1PREMISE。 | 
| hostUrl |  GitHub 主机网址。例如，如果您使用 GitHub SaaS/企业云：。https://api.github.com或者，如果您使用 GitHub本地/企业服务器：。https://on-prem-host-url/api/v3/ | 
| organizationName | 登录到 GitHub 桌面并转到个人资料图片下拉列表下的 “您的组织” 时，可以找到您的组织名称。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将 GitHub 内容的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| isCrawlAcl | true，如果您有访问控制列表（ACL）并想将其用于访问控制，则爬取文档的 ACL 信息。ACL 指定了用户和组可以访问和搜索哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。 | 
| fieldForUser我是 | 指定要用于 ACL 爬取的用户 ID 的类型。如果要使用用户电子邮件作为用户 ID，则指定 email；如果要使用用户名作为用户 ID，则指定 username。如果您不指定选项，则默认使用 email。 | 
| repositoryFilter | 要编制索引的特定存储库和分支名称的列表。 | 
| crawlRepository | 如果为 true，则爬取存储库。 | 
| crawlRepositoryDocuments | 如果为 true，则爬取存储库文档。 | 
| crawlIssue | 如果为 true，则爬取问题。 | 
| crawlIssueComment | 如果为 true，则爬取问题评论。 | 
| crawlIssueComment附件 | 如果为 true，则爬取问题评论附件。 | 
| crawlPullRequest | 如果为 true，则爬取拉取请求。 | 
| crawlPullRequest评论 | 如果为 true，则爬取拉取请求评论。 | 
| crawlPullRequestCommentAttachment | 如果为 true，则爬取拉取请求评论附件。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 GitHub数据源中包含某些内容的正则表达式模式列表。与模式匹配的内容将包含在索引中。与模式不匹配的内容将从索引中排除。如果任何内容同时匹配包含和排除模式，则排除模式优先，该内容不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于排除 GitHub数据源中某些内容的正则表达式模式列表。与模式匹配的内容将从索引中排除。与模式不匹配的内容将包含在索引中。如果任何内容同时匹配包含和排除模式，则排除模式优先，该内容不会包含在索引中。 | 
| 类型 | 数据来源的类型。指定 GITHUB 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn |   AWS Secrets Manager 密钥的 Amazon 资源名称 (ARN)，其中包含连接到您的所需的键值对。 GitHub密钥必须包含具有以下键的 JSON 结构： <pre>{<br />    "personalToken": "token"<br />}</pre>  | 
| version | 当前支持的此模板的版本。 | 

### GitHub JSON 模式
<a name="github-json"></a>

以下是 GitHub JSON 架构：

```
{
    "$schema": "http://json-schema.org/draft-04/schema#",
    "type": "object",
    "properties": {
        "connectionConfiguration": {
            "type": "object",
            "properties": {
                "repositoryEndpointMetadata": {
                    "type": "object",
                    "properties": {
                        "type": {
                            "type": "string"
                        },
                        "hostUrl": {
                            "type": "string",
                            "pattern": "https://.*"
                        },
                        "organizationName": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "type",
                        "hostUrl",
                        "organizationName"
                    ]
                }
            },
            "required": [
                "repositoryEndpointMetadata"
            ]
        },
        "repositoryConfigurations": {
            "type": "object",
            "properties": {
                "ghRepository": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                },
                "ghCommit": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                },
                "ghIssueDocument": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                },
                "ghIssueComment": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                },
                "ghIssueAttachment": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                },
                "ghPRDocument": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                },
                "ghPRComment": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                },
                "ghPRAttachment": {
                    "type": "object",
                    "properties": {
                        "fieldMappings": {
                            "type": "array",
                            "items": [
                                {
                                    "type": "object",
                                    "properties": {
                                        "indexFieldName": {
                                            "type": "string"
                                        },
                                        "indexFieldType": {
                                            "type": "string",
                                            "enum": [
                                                "STRING",
                                                "STRING_LIST",
                                                "DATE"
                                            ]
                                        },
                                        "dataSourceFieldName": {
                                            "type": "string"
                                        },
                                        "dateFieldFormat": {
                                            "type": "string",
                                            "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                                        }
                                    },
                                    "required": [
                                        "indexFieldName",
                                        "indexFieldType",
                                        "dataSourceFieldName"
                                    ]
                                }
                            ]
                        }
                    },
                    "required": [
                        "fieldMappings"
                    ]
                }
            }
        },
        "additionalProperties": {
            "type": "object",
            "properties": {
                "isCrawlAcl": {
                    "type": "boolean"
                },
                "fieldForUserId": {
                    "type": "string"
                },
                "crawlRepository": {
                    "type": "boolean"
                },
                "crawlRepositoryDocuments": {
                    "type": "boolean"
                },
                "crawlIssue": {
                    "type": "boolean"
                },
                "crawlIssueComment": {
                    "type": "boolean"
                },
                "crawlIssueCommentAttachment": {
                    "type": "boolean"
                },
                "crawlPullRequest": {
                    "type": "boolean"
                },
                "crawlPullRequestComment": {
                    "type": "boolean"
                },
                "crawlPullRequestCommentAttachment": {
                    "type": "boolean"
                },
                "repositoryFilter": {
                    "type": "array",
                    "items": [
                        {
                            "type": "object",
                            "properties": {
                                "repositoryName": {
                                    "type": "string"
                                },
                                "branchNameList": {
                                    "type": "array",
                                    "items": {
                                        "type": "string"
                                    }
                                }
                            }
                        }
                    ]
                },
                "inclusionFolderNamePatterns": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "inclusionFileTypePatterns": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "inclusionFileNamePatterns": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "exclusionFolderNamePatterns": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "exclusionFileTypePatterns": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "exclusionFileNamePatterns": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            },
            "required": []
        },
        "type": {
            "type": "string",
            "pattern": "GITHUB"
        },
        "syncMode": {
            "type": "string",
            "enum": [
                "FULL_CRAWL",
                "FORCED_FULL_CRAWL",
                "CHANGE_LOG"
            ]
        },
        "enableIdentityCrawler": {
            "type": "boolean"
        },
        "secretArn": {
            "type": "string",
            "minLength": 20,
            "maxLength": 2048
        }
    },
    "version": {
        "type": "string",
        "anyOf": [
            {
                "pattern": "1.0.0"
            }
        ]
    },
    "required": [
        "connectionConfiguration",
        "repositoryConfigurations",
        "syncMode",
        "additionalProperties",
        "enableIdentityCrawler"
    ]
}
```

## Gmail 模板架构
<a name="ds-gmail-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `GMAIL`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Gmail JSON 架构](#gmail-json)。

下表描述 Gmail JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。此数据来源未在 repositoryEndpointMetadata 中指定端点。相反，连接信息包含在您提供的 AWS Secrets Manager 密钥中secretArn。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  |  将您的 Gmail 邮件和附件的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  |  用于在 Gmail 数据来源中包含或排除特定主题名称的正则表达式模式的列表。与模式匹配的文件将包含在索引中。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| beforeDateFilter | 指定包含特定日期之前的邮件和附件。 | 
| afterDateFilter | 指定包含特定日期之后的邮件和附件。 | 
| isCrawlAttachment | 一个布尔值，用于选择是否要爬取附件。自动爬取邮件。 | 
| 类型 | 数据来源的类型。指定 GMAIL 作为数据来源类型。 | 
| shouldCrawlDraft 消息 | 一个布尔值，用于选择是否要爬取邮件草稿。 | 
| syncMode | 指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  由于没有 API 可以更新永久删除的 Gmail 邮件，所以任何新增、修改或删除的内容同步：   不会从您的 Amazon Kendra 索引中移除从 Gmail 中永久删除的邮件   无法同步 Gmail 电子邮件标签中的更改   要将您的 Gmail 数据源标签更改和永久删除的电子邮件同步到您的 Amazon Kendra 索引，您必须定期进行全面抓取。   | 
| secretARN | Secrets Manager 密钥的 Amazon 资源名称（ARN），该密钥包含连接到 Gmail 所需的键-值对。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "adminAccountEmailId": "service account email",<br />    "clientEmailId": "user account email",<br />    "privateKey": "private key"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Gmail JSON 架构
<a name="gmail-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
      }
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "message": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "STRING_LIST", "DATE"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          }
        },
        "attachments": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          }
        }
      },
      "required": []
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "inclusionLabelNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionLabelNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionAttachmentTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionAttachmentTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionAttachmentNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionAttachmentNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionSubjectFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionSubjectFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "isSubjectAnd": {
          "type": "boolean"
        },
        "inclusionFromFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFromFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionToFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionToFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionCcFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionCcFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionBccFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionBccFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "beforeDateFilter": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
            },
            {
              "type": "string",
              "pattern": ""
            }
          ]
        },
        "afterDateFilter": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
            },
            {
              "type": "string",
              "pattern": ""
            }
          ]
        },
        "isCrawlAttachment": {
          "type": "boolean"
        },
        "shouldCrawlDraftMessages": {
          "type": "boolean"
        }
      },
      "required": [
        "isCrawlAttachment",
        "shouldCrawlDraftMessages"
      ]
    },
    "type" : {
      "type" : "string",
      "pattern": "GMAIL"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL"
      ]
    },
    "secretArn": {
      "type": "string"
    },
    "version": {
      "type": "string",
      "anyOf": [
        {
          "pattern": "1.0.0"
        }
      ]
    }
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "additionalProperties",
    "syncMode",
    "secretArn",
    "type"
  ]
}
```

## Google Drive 模板架构
<a name="ds-googledrive-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `GOOGLEDRIVE2`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Google Drive JSON 架构](#googledrive-json)。

下表描述 Google Drive JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 数据来源的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。此数据来源未指定端点。您可以选择身份验证类型：serviceAccount 和 OAuth2。连接信息包含在您提供的 AWS Secrets Manager 密钥中secretArn。 | 
| authType | 根据您的使用案例，选择 serviceAccount 或 OAuth2。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  |  将 Google Drive 的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象的列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 在中指定 Amazon Kendra 应爬 MBs 行的文件大小限制。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则爬取您的 Google Drive 数据来源中的评论。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | true在您的 Google 云端硬盘数据源中抓取 MyDrive 并与我共享云端硬盘。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则爬取您的 Google Drive 数据来源中的共享云端硬盘。 | 
| isCrawlAcl | true，如果您有访问控制列表（ACL）并想将其用于访问控制，则爬取文档的 ACL 信息。ACL 指定了用户和组可以访问和搜索哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Google Drive 数据来源中排除某些文件的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Google Drive 数据来源中包含某些文件的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| 类型 | 数据来源的类型。指定 GOOOGLEDRIVEV2 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretARN | 包含连接您的 Google 云端硬盘所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。密钥必须包含具有以下键的 JSON 结构：****，如果使用 Google 服务账户身份验证：<pre>{<br />    "clientEmail": "user account email",<br />    "adminAccountEmail": "service account email",<br />    "privateKey": "private key"<br />}</pre> ****如果使用 OAuth 2.0 身份验证： <pre>{<br />    "clientID": "OAuth client ID",<br />    "clientSecret": "client secret",<br />    "refreshToken": "refresh token"<br />}</pre> | 
| 版本 | 当前支持的此模板的版本。 | 

### Google Drive JSON 架构
<a name="googledrive-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "authType": {
              "type": "string",
              "enum": [
                "serviceAccount",
                "OAuth2"
              ]
            }
          },
          "required": [
            "authType"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "file": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "STRING_LIST",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "comment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "STRING_LIST"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "maxFileSizeInMegaBytes": {
          "type": "string"
        },
        "isCrawlComment": {
          "type": "boolean"
        },
        "isCrawlMyDriveAndSharedWithMe": {
          "type": "boolean"
        },
        "isCrawlSharedDrives": {
          "type": "boolean"
        },
        "isCrawlAcl": {
          "type": "boolean"
        },
        "excludeUserAccounts": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "excludeSharedDrives": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "excludeMimeTypes": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "includeUserAccounts": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "includeSharedDrives": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "includeMimeTypes": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "includeTargetAudienceGroup": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionFileNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionFilePathFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFilePathFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "type": {
      "type": "string",
      "pattern": "GOOGLEDRIVEV2"
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## IBM DB2 模板架构
<a name="ds-ibm-db2-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`db2` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[IBM DB2 杰森架构](#ibm-db2-json)。

下表描述了 IBM DB2 JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### IBM DB2 杰森架构
<a name="ibm-db2-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Microsoft Exchange 模板架构
<a name="ds-msexchange-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以将租户 ID 作为连接配置或存储库端点详细信息的一部分提供。还要将数据来源的类型指定为 `MSEXCHANGE`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Microsoft Exchange JSON 架构](#msexchange-json)。

下表描述 Microsoft Exchange JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| tenantId | Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将你的 Microsoft Exchange 数据源的属性或字段名称映射到 Amazon Kendra 索引字段的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项 | 
| inclusionPatterns | 用于在 Microsoft Exchange 数据来源中包含某些文件的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| exclusionPatterns | 用于在 Microsoft Exchange 数据来源中排除某些文件的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Microsoft Exchange 数据来源中包含某些用户的正则表达式模式的列表。与模式匹配的用户将包含在索引中。与模式不匹配的用户将从索引中排除。如果用户同时匹配包含和排除模式，则以排除模式为优先，该用户不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Microsoft Exchange 数据来源中排除某些用户和用户文件的正则表达式模式的列表。与模式匹配的用户将从索引中排除。与模式不匹配的用户将包含在索引中。如果用户同时匹配排除和包含模式，则以排除模式为优先，该用户不会包含在索引中。 | 
| s3bucketName | S3 存储桶的名称（如果要使用）。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则爬取您的 Microsoft Exchange 数据来源的这些类型的内容和访问控制信息。 | 
| startCalendarDate时间 | 您可以为日历内容配置特定的开始日期时间。 | 
| endCalendarDate时间 | 您可以为日历内容配置特定的结束日期时间。 | 
| subject | 您可以为邮件内容配置特定的主题行。 | 
| emailFrom | 您可以为“发件人”或发件人邮件内容配置特定的电子邮件。 | 
| emailTo | 您可以为“收件人”或收件人邮件内容配置特定的电子邮件。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| 类型 | 数据来源的类型。指定 MSEXCHANGE 作为数据来源类型。 | 
| secretARN | 包含连接微软 Exchange 所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。这包括你的客户端 ID 和在 Azure 门户中创建 OAuth应用程序时生成的客户端密钥。 | 
| 版本 | 当前支持的此模板的版本。 | 

### Microsoft Exchange JSON 架构
<a name="msexchange-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "tenantId": {
              "type": "string",
              "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
              "minLength": 36,
              "maxLength": 36
            }
          },
          "required": ["tenantId"]
        }
      }
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "email": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "STRING_LIST", "DATE"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "attachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "DATE","LONG"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "calendar": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "STRING_LIST", "DATE"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "contacts": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "STRING_LIST", "DATE"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "notes": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "DATE"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": ["email"
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "inclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionUsersList": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "email"
          }
        },
        "exclusionUsersList": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "email"
          }
        },
        "s3bucketName": {
          "type": "string"
        },
        "inclusionUsersFileName": {
          "type": "string"
        },
        "exclusionUsersFileName": {
          "type": "string"
        },
        "inclusionDomainUsers": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionDomainUsers": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "crawlCalendar": {
          "type": "boolean"
        },
        "crawlNotes": {
          "type": "boolean"
        },
        "crawlContacts": {
          "type": "boolean"
        },
        "crawlFolderAcl": {
          "type": "boolean"
        },
        "startCalendarDateTime": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
            },
            {
              "type": "string",
              "pattern": ""
            }
          ]
        },
        "endCalendarDateTime": {
          "anyOf": [
            {
            "type": "string",
            "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
            },
            {
              "type": "string",
              "pattern": ""
            }
          ]
        },
        "subject": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "emailFrom": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "email"
          }
        },
        "emailTo": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "email"
          }
        }
      },
      "required": [
      ]
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "type" : {
      "type" : "string",
      "pattern": "MSEXCHANGE"
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## 微软 OneDrive 模板架构
<a name="ds-onedrive-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以将 租户 ID 作为连接配置或存储库端点详细信息的一部分提供。还要将数据来源的类型指定为 `ONEDRIVEV2`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[微软 OneDrive JSON 架构](#onedrive-json)。

下表描述了微软 OneDrive JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| tenantId | Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
| 文件 | 将你的 Microsoft OneDrive 文件的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 您可以选择为特定文件、 OneNote 章节、 OneNote 页面编制索引，并按用户名进行筛选。 | 
| isUserNameonS3 | true 提供存储在 Amazon S3的文件中的用户名列表。 | 
| 类型 | 数据来源的类型。指定 ONEDRIVEV2 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| 类型 | 数据来源的类型。指定 ONEDRIVEV2 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretARN | 包含连接微软所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。 OneDrive密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "clientId": "client ID",<br />    "clientSecret": "client secret"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### 微软 OneDrive JSON 架构
<a name="onedrive-json"></a>

```
{
	"$schema": "http://json-schema.org/draft-04/schema#",
	"type": "object",
	"properties": {
		"connectionConfiguration": {
			"type": "object",
			"properties": {
				"repositoryEndpointMetadata": {
					"type": "object",
					"properties": {
						"tenantId": {
							"type": "string",
							"pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
							"minLength": 36,
							"maxLength": 36
						}
					},
					"required": [
						"tenantId"
					]
				}
			},
			"required": [
				"repositoryEndpointMetadata"
			]
		},
		"repositoryConfigurations": {
			"type": "object",
			"properties": {
				"file": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"STRING_LIST",
												"DATE",
												"LONG"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				}
			}
		},
		"additionalProperties": {
			"type": "object",
			"properties": {
				"userNameFilter": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"userFilterPath": {
					"type": "string"
				},
				"isUserNameOnS3": {
					"type": "boolean"
				},
				"inclusionFileTypePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionFileTypePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionFileNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionFileNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionFilePathPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionFilePathPatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionOneNoteSectionNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionOneNoteSectionNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionOneNotePageNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionOneNotePageNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				}
			},
			"required": []
		},

		"enableIdentityCrawler": {
			"type": "boolean"
		},
		"type": {
			"type": "string",
			"pattern": "ONEDRIVEV2"
		},
		"syncMode": {
			"type": "string",
			"enum": [
				"FULL_CRAWL",
				"FORCED_FULL_CRAWL",
				"CHANGE_LOG"
			]
		},
		"secretArn": {
			"type": "string",
			"minLength": 20,
			"maxLength": 2048
		}
	},
	"version": {
		"type": "string",
		"anyOf": [
			{
				"pattern": "1.0.0"
			}
		]
	},
	"required": [
		"connectionConfiguration",
		"repositoryConfigurations",
		"syncMode",
		"additionalProperties",
		"secretArn",
		"type"
	]
}
```

## 微软 SharePoint 模板架构
<a name="ds-schema-sharepoint"></a>

您将包含包含数据源架构的 JSON 作为[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象的一部分。在连接配置或存储库端点URLs详细信息中，您可以提供 SharePoint 站点 URL/、域以及租户 ID（如果需要）。还要将数据来源的类型指定为 `SHAREPOINTV2`、身份验证凭证的密钥以及其他必要的配置。然后在呼叫时指定`TEMPLATE`为 “**类型**” [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)。

您可以使用本开发者指南中提供的模板。请参阅[SharePoint JSON 模式](#sharepoint-json)。

下表描述了微软 SharePoint JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息 | 
| repositoryEndpointMetadata | 数据来源的端点信息 | 
| tenantId | 您 SharePoint 账户的租户 ID。 | 
| 域 | 您 SharePoint 账户的域名。 | 
| siteUrls | 您的 SharePoint 账户 URLs 的主机。 | 
| repositoryAdditionalProperties | 用于连接 repository/data 源端点的其他属性。 | 
| s3bucketName | 存储 Azure AD 自签名 X.509 证书的 Amazon S3 存储桶的名称。 | 
| s3certificateName | 存储在存储桶中的 Azure AD 自签名 X.509 证书的名称。 Amazon S3  | 
| authType | 您使用的身份验证类型，可以是 OAuth2、OAuth2Certificate、OAuth2App、Basic、OAuth2\$1RefreshToken、NTLM 或 Kerberos。 | 
| 版本 | 您使用的 SharePoint 版本，Server无论是Online。 | 
| onPremVersion | 您使用的 SharePoint 服务器版本，是201320162019、或SubscriptionEdition。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将 SharePoint内容的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) |  SharePoint 数据源中 include/exclude 某些内容的正则表达式模式列表。与包含模式匹配的内容项将包含在索引中。与包含模式不匹配的内容项将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 如果为 true，则爬取这些类型的内容。 | 
| crawlAcl | true，如果您有访问控制列表（ACL）并想将其用于访问控制，则爬取文档的 ACL 信息。ACL 指定了用户和组可以访问和搜索哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。 | 
| fieldForUser我是 | 如果要使用用户电子邮件作为用户 ID，则指定 email；如果要使用用户名作为用户 ID，则指定 userPrincipalName。如果您不指定选项，则默认使用 email。 | 
| aclConfiguration | 指定 ACLWithLDAPEmailFmt、ACLWithManualEmailFmt 或 ACLWithUsernameFmtM。 | 
| emailDomain | 电子邮件的域名。例如，“amazon.com”。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则爬取群组映射信息。 | 
| proxyHost | 您使用的 Web 代理的主机名，其中不包含 http:// 或 https:// 协议。 | 
| proxyPort | 主机 URL 传输协议使用的端口号。必须是介于 0 和 65535 之间的数值。 | 
| 类型 | 指定 SHAREPOINTV2 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretARN |  AWS Secrets Manager 密钥的 Amazon 资源名称 (ARN)，其中包含连接到您的所需的键值对。 SharePoint有关这些键值对的信息，请参阅 On [ SharePoint line 和 SharePoint Server 的连接说明](https://docs.aws.amazon.com/kendra/latest/dg/data-source-v2-sharepoint.html#data-source-procedure-v2-sharepoint)。 | 
| 版本 | 当前支持的此模板的版本。 | 

## SharePoint JSON 模式
<a name="sharepoint-json"></a>

```
{
	"$schema": "http://json-schema.org/draft-04/schema#",
	"type": "object",
	"properties": {
		"connectionConfiguration": {
			"type": "object",
			"properties": {
				"repositoryEndpointMetadata": {
					"type": "object",
					"properties": {
						"tenantId": {
							"type": "string",
							"pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
							"minLength": 36,
							"maxLength": 36
						},
						"domain": {
							"type": "string"
						},
						"siteUrls": {
							"type": "array",
							"items": {
								"type": "string",
								"pattern": "https://.*"
							}
						},
						"repositoryAdditionalProperties": {
							"type": "object",
							"properties": {
								"s3bucketName": {
									"type": "string"
								},
								"s3certificateName": {
									"type": "string"
								},
								"authType": {
									"type": "string",
									"enum": [
										"OAuth2",
										"OAuth2Certificate",
										"OAuth2App",
										"Basic",
										"OAuth2_RefreshToken",
										"NTLM",
										"Kerberos"
									]
								},
								"version": {
									"type": "string",
									"enum": [
										"Server",
										"Online"
									]
								},
								"onPremVersion": {
									"type": "string",
									"enum": [
										"",
										"2013",
										"2016",
										"2019",
										"SubscriptionEdition"
									]
								}
							},
							"required": [
								"authType",
								"version"
							]
						}
					},
					"required": [
						"siteUrls",
						"domain",
						"repositoryAdditionalProperties"
					]
				}
			},
			"required": [
				"repositoryEndpointMetadata"
			]
		},
		"repositoryConfigurations": {
			"type": "object",
			"properties": {
				"event": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"STRING_LIST",
												"DATE"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				},
				"page": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"DATE",
												"LONG"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				},
				"file": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"DATE",
												"LONG"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				},
				"link": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"STRING_LIST",
												"DATE"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				},
				"attachment": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"STRING_LIST",
												"DATE"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				},
				"comment": {
					"type": "object",
					"properties": {
						"fieldMappings": {
							"type": "array",
							"items": [
								{
									"type": "object",
									"properties": {
										"indexFieldName": {
											"type": "string"
										},
										"indexFieldType": {
											"type": "string",
											"enum": [
												"STRING",
												"STRING_LIST",
												"DATE"
											]
										},
										"dataSourceFieldName": {
											"type": "string"
										},
										"dateFieldFormat": {
											"type": "string",
											"pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
										}
									},
									"required": [
										"indexFieldName",
										"indexFieldType",
										"dataSourceFieldName"
									]
								}
							]
						}
					},
					"required": [
						"fieldMappings"
					]
				}
			}
		},
		"additionalProperties": {
			"type": "object",
			"properties": {
				"eventTitleFilterRegEx": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"pageTitleFilterRegEx": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"linkTitleFilterRegEx": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionFilePath": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionFilePath": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionFileTypePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionFileTypePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionFileNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionFileNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionOneNoteSectionNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionOneNoteSectionNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"inclusionOneNotePageNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"exclusionOneNotePageNamePatterns": {
					"type": "array",
					"items": {
						"type": "string"
					}
				},
				"crawlFiles": {
					"type": "boolean"
				},
				"crawlPages": {
					"type": "boolean"
				},
				"crawlEvents": {
					"type": "boolean"
				},
				"crawlComments": {
					"type": "boolean"
				},
				"crawlLinks": {
					"type": "boolean"
				},
				"crawlAttachments": {
					"type": "boolean"
				},
				"crawlListData": {
					"type": "boolean"
				},
				"crawlAcl": {
					"type": "boolean"
				},
				"fieldForUserId": {
					"type": "string"
				},
				"aclConfiguration": {
					"type": "string",
					"enum": [
						"ACLWithLDAPEmailFmt",
						"ACLWithManualEmailFmt",
						"ACLWithUsernameFmt"
					]
				},
				"emailDomain": {
					"type": "string"
				},
				"isCrawlLocalGroupMapping": {
					"type": "boolean"
				},
				"isCrawlAdGroupMapping": {
					"type": "boolean"
				},
				"proxyHost": {
					"type": "string"
				},
				"proxyPort": {
					"type": "string"
				}
			},
			"required": [
			]
		},
		"type": {
			"type": "string",
			"pattern": "SHAREPOINTV2"
		},
		"enableIdentityCrawler": {
			"type": "boolean"
		},
		"syncMode": {
			"type": "string",
			"enum": [
				"FULL_CRAWL",
				"FORCED_FULL_CRAWL",
				"CHANGE_LOG"
			]
		},
		"secretArn": {
			"type": "string",
			"minLength": 20,
			"maxLength": 2048
		}
	},
	"version": {
		"type": "string",
		"anyOf": [
			{
				"pattern": "1.0.0"
			}
		]
	},
	"required": [
		"connectionConfiguration",
		"repositoryConfigurations",
		"enableIdentityCrawler",
		"syncMode",
		"additionalProperties",
		"secretArn",
		"type"
	]
}
```

## Microsoft SQL Server 模板架构
<a name="ds-ms-sql-server-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`sqlserver` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Microsoft SQL Server JSON 架构](#ms-sql-server-json)。

下表描述 Micorosft SQL Server JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Microsoft SQL Server JSON 架构
<a name="ms-sql-server-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Microsoft Teams 模板架构
<a name="ds-msteams-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以将租户 ID 作为连接配置或存储库端点详细信息的一部分提供。还要将数据来源的类型指定为 `MSTEAMS`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Microsoft Teams JSON 架构](#msteams-json)。

下表描述 Microsoft Teams JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| tenantId | Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将你的 Microsoft Teams 内容的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| paymentModel | 指定用于您的 Microsoft Teams 数据来源的支付模式类型。A 型支付模式仅限于需要安全合规的许可和支付模式。B 型支付模式适用于不需要安全合规的许可和支付模式。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Microsoft Teams 数据来源中包含某些内容的正则表达式模式的列表。与模式匹配的内容将包含在索引中。与模式不匹配的内容将从索引中排除。如果内容同时匹配包含和排除模式，则以排除模式为优先，该内容不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Microsoft Teams 数据来源中排除某些内容的正则表达式模式的列表。与模式匹配的内容将从索引中排除。与模式不匹配的内容将包含在索引中。如果内容同时匹配包含和排除模式，则以排除模式为优先，该内容不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则在您的 Microsoft Teams 数据来源中爬取这些类型的内容。 | 
| startCalendarDate时间 | 您可以为日历内容配置特定的开始日期时间。 | 
| endCalendarDate时间 | 您可以为日历内容配置特定的结束日期时间。 | 
| 类型 | 数据来源的类型。指定 MSTEAMS 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn |  AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)，其中包含连接你的 Microsoft Teams 所需的键值对。这包括在 Azure 门户中创建 OAuth 应用程序时生成的客户端 ID 和客户端密钥。 | 
| 版本 | 当前支持的此模板的版本。 | 

### Microsoft Teams JSON 架构
<a name="msteams-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "tenantId": {
              "type": "string",
              "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
              "minLength": 36,
              "maxLength": 36
            }
          },
          "required": [
            "tenantId"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "chatMessage": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "chatAttachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "channelPost": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "channelWiki": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "channelAttachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "meetingChat": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "meetingFile": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "meetingNote": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "calendarMeeting": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
     "additionalProperties": {
      "type": "object",
      "properties": {
        "paymentModel": {
          "type": "string",
          "enum": [
            "A",
            "B",
            "Evaluation Mode"
          ]
        },
        "inclusionTeamNameFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionTeamNameFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionChannelNameFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionChannelNameFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionFileNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionUserEmailFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionOneNoteSectionNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionOneNoteSectionNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionOneNotePageNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionOneNotePageNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "isCrawlChatMessage": {
          "type": "boolean"
        },
        "isCrawlChatAttachment": {
          "type": "boolean"
        },
        "isCrawlChannelPost": {
          "type": "boolean"
        },
        "isCrawlChannelAttachment": {
          "type": "boolean"
        },
        "isCrawlChannelWiki": {
          "type": "boolean"
        },
        "isCrawlCalendarMeeting": {
          "type": "boolean"
        },
        "isCrawlMeetingChat": {
          "type": "boolean"
        },
        "isCrawlMeetingFile": {
          "type": "boolean"
        },
        "isCrawlMeetingNote": {
          "type": "boolean"
        },
        "startCalendarDateTime": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
            },
            {
              "type": "string",
              "pattern": ""
            }
          ]
        },
        "endCalendarDateTime": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
            },
            {
              "type": "string",
              "pattern": ""
            }
          ]
        }
      },
      "required": []
    },
    "type": {
      "type": "string",
      "pattern": "MSTEAMS"
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## Microsoft Yammer 模板架构
<a name="ds-schema-yammer"></a>

您将包含包含数据源架构的 JSON 作为[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象的一部分。将数据来源的类型指定为 `YAMMER`、身份验证凭证的密钥以及其他必要的配置。然后在呼叫时指定`TEMPLATE`为 “**类型**” [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)。

您可以使用本开发者指南中提供的模板。

下表描述 Microsoft Yammer JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 数据来源的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。此数据来源未在 repositoryEndpointMetadata 中指定端点。相反，连接信息包含在您提供的 AWS Secrets Manager 密钥中secretArn。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将 Microsoft Yammer 内容的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象的列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项 | 
| inclusionPatterns | 用于在 Microsoft Yammer 数据来源中包含某些文件的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| exclusionPatterns | 用于在 Microsoft Yammer 数据来源中排除某些文件的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| sinceDate | 您可以选择配置一个 sinceDate 参数，以便 Microsoft Yammer 连接器根据特定的 sinceDate 爬取内容。 | 
| communityNameFilter | 您可以选择将特定的社区内容编入索引。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则爬取消息、邮件附件和私人消息。 | 
| 类型 | 指定 YAMMER 作为数据来源类型。 | 
| secretARN |  AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)，其中包含连接你的 Microsoft Yammer 所需的键值对。这包括你的 Microsoft Yammer 用户名和密码，以及在 Azure 门户中创建 OAuth 应用程序时生成的客户端 ID 和客户端密钥。 | 
| useChangeLog | 如果为 true，则使用 Microsoft Yammer 更改日志来确定需要在索引中更新哪些文档。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 

### Microsoft Yammer JSON 架构
<a name="yammer-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
          }
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "community": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "user": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "message": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "attachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": [
                          "STRING",
                          "DATE"
                        ]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "inclusionPatterns": {
          "type": "array"
        },
        "exclusionPatterns": {
          "type": "array"
        },
        "sinceDate": {
          "type": "string",
          "pattern": "^(19|2[0-9])[0-9]{2}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])((\\+|-)(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]))?$"
        },
        "communityNameFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "isCrawlMessage": {
          "type": "boolean"
        },
        "isCrawlAttachment": {
          "type": "boolean"
        },
        "isCrawlPrivateMessage": {
          "type": "boolean"
        }
      },
      "required": [
        "sinceDate"
      ]
    },
    "type": {
      "type": "string",
      "pattern": "YAMMER"
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    },
    "useChangeLog": {
      "type": "string",
      "enum": [
        "true",
        "false"
      ]
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "version": {
      "type": "string",
      "anyOf": [
        {
          "pattern": "1.0.0"
        }
      ]
    }
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "additionalProperties",
    "type",
    "secretArn",
    "syncMode"
  ]
}
```

## MySQL 模板架构
<a name="ds-mysql-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`mysql` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[MySQL JSON 架构](#mysql-json)。

下表描述 MySQL JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### MySQL JSON 架构
<a name="mysql-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Oracle Database 模板架构
<a name="ds-oracle-database-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`oracle` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Oracle Database JSON 架构](#oracle-database-json)。

下表描述 Oracle Database JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### Oracle Database JSON 架构
<a name="oracle-database-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## PostgreSQL 模板架构
<a name="ds-postgresql-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。将数据来源的类型指定为 `JDBC`、`postgresql` 的数据库类型、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[PostgreSQL JSON 架构](#postgresql-json)。

下表描述 PostgreSQL JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 连接数据来源所需的配置信息。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html) | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。指定数据来源的类型和密钥 ARN。 | 
|  文档  |  将数据库内容的属性或字段名映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| additionalProperties | 数据来源中内容的其他配置选项。用于在数据库数据来源中包含或排除特定内容。 | 
| primaryKey  | 提供数据库表的主键。这将标识数据库中的表。 | 
| titleColumn | 提供数据库表中文档标题列的名称。 | 
| bodyColumn | 提供数据库表中文档标题列的名称。 | 
| sqlQuery | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| timestampColumn | 输入包含时间戳的列的名称。 Amazon Kendra 使用时间戳信息来检测内容的变化并仅同步已更改的内容。 | 
| timestampFormat | 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。 | 
| timezone | 输入列的名称，该列包含要搜索的内容的时区。 | 
| changeDetectingColumns | 输入 Amazon Kendra 将用于检测内容更改的列的名称。 Amazon Kendra 当其中任何一列发生变化时，将重新索引内容 | 
| allowedUsersColumns | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| allowedGroupsColumn | 输入包含允许用户访问内容 IDs 的列的名称。 | 
| 来源 URIColumn | 输入包含要编制索引的来源 URLs 的列的名称。 | 
| isSslEnabled | 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。 Amazon Kendra 将抓取与您的查询相匹配的所有数据库内容。 | 
| 类型 | 数据来源的类型。指定 JDBC 作为数据来源类型。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretArn | Secrets Manager 密钥的 Amazon 资源名称（ARN），其中包含连接到数据库时需要的用户名和密码。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "user name": "database user name",<br />    "password": "password"<br />}</pre> | 
| version | 当前支持的此模板的版本。 | 

### PostgreSQL JSON 架构
<a name="postgresql-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "dbType": {
              "type": "string",
              "enum": [
                "mysql",
                "db2",
                "postgresql",
                "oracle",
                "sqlserver"
              ]
            },
            "dbHost": {
              "type": "string"
            },
            "dbPort": {
              "type": "string"
            },
            "dbInstance": {
              "type": "string"
            }
          },
          "required": [
            "dbType",
            "dbHost",
            "dbPort",
            "dbInstance"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "document": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string"
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "type": "string"
        },
        "titleColumn": {
          "type": "string"
        },
        "bodyColumn": {
          "type": "string"
        },
        "sqlQuery": {
          "type": "string",
          "not": {
            "pattern": ";+"
          }
        },
        "timestampColumn": {
          "type": "string"
        },
        "timestampFormat": {
          "type": "string"
        },
        "timezone": {
          "type": "string"
        },
        "changeDetectingColumns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "allowedUsersColumn": {
          "type": "string"
        },
        "allowedGroupsColumn": {
          "type": "string"
        },
        "sourceURIColumn": {
          "type": "string"
        },
        "isSslEnabled": {
          "type": "boolean"
        }
      },
      "required": ["primaryKey", "titleColumn", "bodyColumn", "sqlQuery"]
    },
    "type" : {
      "type" : "string",
      "pattern": "JDBC"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
      "connectionConfiguration",
      "repositoryConfigurations",
      "syncMode",
      "additionalProperties",
      "secretArn",
      "type"
  ]
}
```

## Salesforce 模板架构
<a name="ds-salesforce-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以将 Salesforc 主机 URL 作为连接配置或存储库端点详细信息的一部分提供。还要将数据来源的类型指定为 `SALESFORCEV2`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Salesforce JSON 架构](#salesforce-json)。

下表描述 Salesforce JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| hostUrl | 要编制索引的 Salesforce 实例的 URL。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  |  将您的 Salesforce 实体的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| secretARN | 包含连接您的 Salesforce 所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "authenticationUrl": "OAUTH endpoint that Amazon Kendra connects to get an OAUTH token",<br />    "consumerKey": "Application public key generated when you created your Salesforce application",<br />    "consumerSecret": "Application private key generated when you created your Salesforce application",<br />    "password": "Password associated with the user logging in to the Salesforce instance",<br />    "securityToken": "Token associated with the user account logging in to the Salesforce instance",<br />    "username": "User name of the user logging in to the Salesforce instance"<br />}</pre> | 
| additionalProperties | 数据来源中内容的其他配置选项 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 一组字符串，用于指定要筛选的实体。 | 
| inclusionPatterns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Salesforce 数据来源中包含某些文件的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| exclusionPatterns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 用于在 Salesforce 数据来源中排除某些文件的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 如果为 true，则在您的 Salesforce 账户中爬取这些类型的文件。 | 
| 类型 | 数据来源的类型。指定 SALESFORCEV2 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| 版本 | 当前支持的此模板的版本。 | 

### Salesforce JSON 架构
<a name="salesforce-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties":
  {
    "connectionConfiguration": {
      "type": "object",
      "properties":
      {
        "repositoryEndpointMetadata":
        {
          "type": "object",
          "properties":
          {
            "hostUrl":
            {
              "type": "string",
              "pattern": "https:.*"
            }
          },
          "required":
          [
            "hostUrl"
          ]
        }
      },
      "required":
      [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties":
      {
        "account":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "contact":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "campaign":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "case":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "product":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "lead":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "contract":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "partner":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "profile":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "idea":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "pricebook":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "task":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "solution":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "attachment":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "user":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "document":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "knowledgeArticles":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "group":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "opportunity":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE",
                        "LONG"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "chatter":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        },
        "customEntity":
        {
          "type": "object",
          "properties":
          {
            "fieldMappings":
            {
              "type": "array",
              "items":
              [
                {
                  "type": "object",
                  "properties":
                  {
                    "indexFieldName":
                    {
                      "type": "string"
                    },
                    "indexFieldType":
                    {
                      "type": "string",
                      "enum":
                      [
                        "STRING",
                        "STRING_LIST",
                        "DATE"
                      ]
                    },
                    "dataSourceFieldName":
                    {
                      "type": "string"
                    },
                    "dateFieldFormat":
                    {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required":
                  [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required":
          [
            "fieldMappings"
          ]
        }
      }
    },
    "additionalProperties": {
      "type": "object",
      "properties":
      {
        "accountFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "contactFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "caseFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "campaignFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "contractFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "groupFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "leadFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "productFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "opportunityFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "partnerFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "pricebookFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "ideaFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "profileFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "taskFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "solutionFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "userFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "chatterFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "documentFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "knowledgeArticleFilter":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "customEntities":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "isCrawlAccount": {
          "type": "boolean"
        },
        "isCrawlContact": {
          "type": "boolean"
        },
        "isCrawlCase": {
          "type": "boolean"
        },
        "isCrawlCampaign": {
          "type": "boolean"
        },
        "isCrawlProduct": {
          "type": "boolean"
        },
        "isCrawlLead": {
          "type": "boolean"
        },
        "isCrawlContract": {
          "type": "boolean"
        },
        "isCrawlPartner": {
          "type": "boolean"
        },
        "isCrawlProfile": {
          "type": "boolean"
        },
        "isCrawlIdea": {
          "type": "boolean"
        },
        "isCrawlPricebook": {
          "type": "boolean"
        },
        "isCrawlDocument": {
          "type": "boolean"
        },
        "crawlSharedDocument": {
          "type": "boolean"
        },
        "isCrawlGroup": {
          "type": "boolean"
        },
        "isCrawlOpportunity": {
          "type": "boolean"
        },
        "isCrawlChatter": {
          "type": "boolean"
        },
        "isCrawlUser": {
          "type": "boolean"
        },
        "isCrawlSolution":{
          "type": "boolean"
        },
        "isCrawlTask":{
          "type": "boolean"
        },

        "isCrawlAccountAttachments": {
          "type": "boolean"
        },
        "isCrawlContactAttachments": {
          "type": "boolean"
        },
        "isCrawlCaseAttachments": {
          "type": "boolean"
        },
        "isCrawlCampaignAttachments": {
          "type": "boolean"
        },
        "isCrawlLeadAttachments": {
          "type": "boolean"
        },
        "isCrawlContractAttachments": {
          "type": "boolean"
        },
        "isCrawlGroupAttachments": {
          "type": "boolean"
        },
        "isCrawlOpportunityAttachments": {
          "type": "boolean"
        },
        "isCrawlChatterAttachments": {
          "type": "boolean"
        },
        "isCrawlSolutionAttachments":{
          "type": "boolean"
        },
        "isCrawlTaskAttachments":{
          "type": "boolean"
        },
        "isCrawlCustomEntityAttachments":{
          "type": "boolean"
        },
        "isCrawlKnowledgeArticles": {
          "type": "object",
          "properties":
          {
            "isCrawlDraft": {
              "type": "boolean"
            },
            "isCrawlPublish": {
              "type": "boolean"
            },
            "isCrawlArchived": {
              "type": "boolean"
            }
          }
        },
        "inclusionDocumentFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionDocumentFileTypePatterns": {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionDocumentFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionDocumentFileNamePatterns": {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionAccountFileTypePatterns": {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionAccountFileTypePatterns": {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionAccountFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionAccountFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionCampaignFileTypePatterns": {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionCampaignFileTypePatterns": {
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionCampaignFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionCampaignFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionCaseFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionCaseFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionCaseFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionCaseFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionContactFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionContactFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionContactFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionContactFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionContractFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionContractFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionContractFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionContractFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionLeadFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionLeadFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionLeadFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionLeadFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionOpportunityFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionOpportunityFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionOpportunityFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionOpportunityFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionSolutionFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionSolutionFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionSolutionFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionSolutionFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionTaskFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionTaskFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionTaskFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionTaskFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionGroupFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionGroupFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionGroupFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionGroupFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionChatterFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionChatterFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionChatterFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionChatterFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionCustomEntityFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionCustomEntityFileTypePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "inclusionCustomEntityFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        },
        "exclusionCustomEntityFileNamePatterns":{
          "type": "array",
          "items":
          {
            "type": "string"
          }
        }
      },
      "required":
      []
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "type": {
      "type": "string",
      "pattern": "SALESFORCEV2"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FULL_CRAWL",
        "FORCED_FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## ServiceNow 模板架构
<a name="ds-servicenow-schema"></a>

您可以将包含数据来源架构的 JSON 作为 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象的一部分。您可以在连接配置或存储库端点详细信息中提供 ServiceNow 主机 URL、身份验证类型和实例版本。还要将数据来源的类型指定为 `SERVICENOWV2`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[ServiceNow JSON 模式](#servicenow-json)。

下表描述了 ServiceNow JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| hostUrl |  ServiceNow 主机网址。例如 your-domain.service-now.com。 | 
| authType | 您使用的身份验证类型，可以是 basicAuth 或 OAuth2。 | 
| servicenowInstanceVersion | 您使用的 ServiceNow 版本。您可在 Tokyo、Sandiego、Rome 和 Others 之间选择。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将 ServiceNow知识文章、附件、服务目录和事件的属性或字段名称映射到 Amazon Kendra 索引字段名的对象列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 ServiceNow 数据源字段名称必须存在于您的 ServiceNow 自定义元数据中。 | 
| 其他属性 | 数据来源中内容的其他配置选项。 | 
| maxFileSizeInMegaBytes | 指定 Amazon Kendra 将抓取的文件大小限制。 MBs Amazon Kendra 将仅爬取您定义的大小限制范围内的文件。默认文件大小为 50 MB。最大文件大小应大于 0 MB 且小于或等于 50 MB。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 要包含的正则表达式模式列表， and/or 排除 ServiceNow 数据源中的某些文件。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | true搜寻 ServiceNow 知识文章、服务目录、事件和附件。 | 
| 类型 | 数据来源的类型。指定 SERVICENOWV2 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| syncMode | 指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| secretARN |  AWS Secrets Manager 密钥的 Amazon 资源名称 (ARN)，其中包含连接到您的所需的键值对。 ServiceNow密钥必须包含具有以下键的 JSON 结构：<pre>{<br />    "username": "user name",<br />    "password": "password"<br />}</pre> 如果您使用 OAuth2 身份验证，则您的密钥必须包含带有以下密钥的 JSON 结构：<pre>{<br />    "username": "user name",<br />    "password": "password",<br />    "clientId": "client id",<br />    "clientSecret": "client secret"         <br />}</pre>  | 
| version | 当前支持的此模板的版本。 | 

### ServiceNow JSON 模式
<a name="servicenow-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "hostUrl": {
              "type": "string",
              "pattern": "^(?!(^(https?|ftp|file):\/\/))[a-z0-9-]+(.service-now.com|.servicenowservices.com)$",
              "minLength": 1,
              "maxLength": 2048
            },
            "authType": {
              "type": "string",
              "enum": [
                "basicAuth",
                "OAuth2"
              ]
            },
            "servicenowInstanceVersion": {
              "type": "string",
              "enum": [
                "Tokyo",
                "Sandiego",
                "Rome",
                "Others"
                ]
            }
          },
          "required": [
            "hostUrl",
            "authType",
            "servicenowInstanceVersion"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "knowledgeArticle": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "STRING_LIST"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "attachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "LONG",
                        "DATE",
                        "STRING_LIST"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "serviceCatalog": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "STRING_LIST"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "incident": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": [
                        "STRING",
                        "DATE",
                        "STRING_LIST"
                      ]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "maxFileSizeInMegaBytes": {
          "type": "string"
        },
        "isCrawlKnowledgeArticle": {
          "type": "boolean"
        },
        "isCrawlKnowledgeArticleAttachment": {
          "type": "boolean"
        },
        "includePublicArticlesOnly": {
          "type": "boolean"
        },
        "knowledgeArticleFilter": {
          "type": "string"
        },
        "incidentQueryFilter": {
          "type": "string"
        },
        "serviceCatalogQueryFilter": {
          "type": "string"
        },
        "isCrawlServiceCatalog": {
          "type": "boolean"
        },
        "isCrawlServiceCatalogAttachment": {
          "type": "boolean"
        },
        "isCrawlActiveServiceCatalog": {
          "type": "boolean"
        },
        "isCrawlInactiveServiceCatalog": {
          "type": "boolean"
        },
        "isCrawlIncident": {
          "type": "boolean"
        },
        "isCrawlIncidentAttachment": {
          "type": "boolean"
        },
        "isCrawlActiveIncident": {
          "type": "boolean"
        },
        "isCrawlInactiveIncident": {
          "type": "boolean"
        },
        "applyACLForKnowledgeArticle": {
          "type": "boolean"
        },
        "applyACLForServiceCatalog": {
          "type": "boolean"
        },
        "applyACLForIncident": {
          "type": "boolean"
        },
        "incidentStateType": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "Open",
              "Open - Unassigned",
              "Resolved",
              "All"
            ]
          }
        },
        "knowledgeArticleTitleRegExp": {
          "type": "string"
        },
        "serviceCatalogTitleRegExp": {
          "type": "string"
        },
        "incidentTitleRegExp": {
          "type": "string"
        },
        "inclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileTypePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionFileNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "exclusionFileNamePatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "required": []
    },
    "type": {
      "type": "string",
      "pattern": "SERVICENOWV2"
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL"
      ]
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type"
  ]
}
```

## Slack 模板架构
<a name="ds-schema-slack"></a>

您将包含包含数据源架构的 JSON 作为[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象的一部分。您可以将主机 URL 作为连接配置或存储库端点详细信息的一部分提供。还要将数据来源的类型指定为 `SLACK`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Slack JSON 架构](#slack-json)。

下表描述 Slack JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| teamId | 您从 Slack 主页 URL 中复制的 Slack 团队 ID。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
| 全部 | 将Slack内容的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象列表。 | 
| additionalProperties | 数据来源中内容的其他配置选项。 | 
| inclusionPatterns | 用于包含 Slack 数据来源中特定内容的正则表达式模式的列表。与模式匹配的内容将包含在索引中。与模式不匹配的内容将从索引中排除。如果任何内容同时匹配包含和排除模式，则排除模式优先，该内容不会包含在索引中。 | 
| exclusionPatterns | 用于排除 Slack 数据来源中特定内容的正则表达式模式的列表。与模式匹配的内容将从索引中排除。与模式不匹配的内容将包含在索引中。如果任何内容同时匹配包含和排除模式，则排除模式优先，该内容不会包含在索引中。 | 
| crawlBotMessages | true抓取机器人消息。 | 
| excludeArchived | 如果为 true，则在爬取时排除已存档的邮件。 | 
| conversationType | 要编制索引的对话的类型，可以是 PUBLIC\$1CHANNEL、PRIVATE\$1CHANNEL、GROUP\$1MESSAGE 或 DIRECT\$1MESSAGE。 | 
| channelFilter | 您要编制索引的通道的类型，可以为 private\$1channel 或 public\$1channel。 | 
| sinceDate | 您可以选择配置 sinceDate 参数，以便 Slack 连接器根据特定的 sinceDate 爬取内容。 | 
| lookBack | 您可以选择配置 lookBack 参数，以便 Slack 连接器能够爬取在上次连接器同步前指定小时数内被更新或删除的内容。 | 
| syncMode |  指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。您可以选择： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 
| 类型 | 数据来源的类型。指定 SLACK 作为数据来源类型。 | 
| enableIdentityCrawler | true使用 Amazon Kendra身份搜寻器来同步有权访问某些文档的用户和群组 identity/principal 的信息。如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制，但身份爬网程序已关闭，则可以选择使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html](https://docs.aws.amazon.com/kendra/latest/dg/API_PutPrincipalMapping.html) API 上传用户和组访问信息。 | 
| secretArn |   AWS Secrets Manager 密钥的 Amazon 资源名称 (ARN)，其中包含连接到您的所需的键值对。Slack密钥必须包含具有以下键的 JSON 结构： <pre>{<br />    "slackToken": "token"<br />}</pre>  | 
| version | 当前支持的此模板的版本。 | 

### Slack JSON 架构
<a name="slack-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "teamId": {
              "type": "string"
            }
          },
          "required": ["teamId"]
        }
      }
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "All": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "indexFieldName": {
                      "type": "string"
                    },
                    "indexFieldType": {
                      "type": "string",
                      "enum": ["STRING", "STRING_LIST", "DATE","LONG"]
                    },
                    "dataSourceFieldName": {
                      "type": "string"
                    },
                    "dateFieldFormat": {
                      "type": "string",
                      "pattern": "yyyy-MM-dd'T'HH:mm:ss'Z'"
                    }
                  },
                  "required": [
                    "indexFieldName",
                    "indexFieldType",
                    "dataSourceFieldName"
                  ]
                }
              ]
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      },
      "required": [
      ]
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "exclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "inclusionPatterns": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "crawlBotMessages": {
          "type": "boolean"
        },
        "excludeArchived": {
          "type": "boolean"
        },
        "conversationType": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "PUBLIC_CHANNEL",
              "PRIVATE_CHANNEL",
              "GROUP_MESSAGE",
              "DIRECT_MESSAGE"
            ]
          }
        },
        "channelFilter": {
            "type": "object",
            "properties": {
              "private_channel": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "public_channel": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
          }
        },
        "channelIdFilter": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "sinceDate": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
            },
            {
              "type": "string",
              "pattern": ""
            }
          ]
        },
        "lookBack": {
          "type": "string",
          "pattern": "^[0-9]*$"
        }
      },
      "required": [
      ]
    },
    "syncMode": {
      "type": "string",
      "enum": [
        "FORCED_FULL_CRAWL",
        "FULL_CRAWL",
        "CHANGE_LOG"
      ]
    },
    "type" : {
      "type" : "string",
      "pattern": "SLACK"
    },
    "enableIdentityCrawler": {
      "type": "boolean"
    },
    "secretArn": {
      "type": "string"
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "syncMode",
    "additionalProperties",
    "secretArn",
    "type",
    "enableIdentityCrawler"
  ]
}
```

## Zendesk 模板架构
<a name="ds-schema-zendesk"></a>

您将包含包含数据源架构的 JSON 作为[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象的一部分。您可以将主机 URL 作为连接配置或存储库端点详细信息的一部分提供。还要将数据来源的类型指定为 `ZENDESK`、身份验证凭证的密钥以及其他必要的配置。然后，当您 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) 时，您可以将 `TEMPLATE` 指定为 `Type`。

您可以使用本开发者指南中提供的模板。请参阅[Zendesk JSON 架构](#zendesk-json)。

下表描述 Zendesk JSON 架构的参数。


| 配置 | 说明 | 
| --- | --- | 
| connectionConfiguration | 有关数据来源端点的配置信息。 | 
| repositoryEndpointMetadata | 数据来源的端点信息。 | 
| hostURL | Zendesk 主机 URL。例如 https://yoursubdomain.zendesk.com。 | 
| repositoryConfigurations | 数据来源内容的配置信息。例如，配置特定类型的内容和字段映射。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 将 Zendesk 工单的属性或字段名称映射到 Amazon Kendra 索引字段名称的对象的列表。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。 | 
| secretARN | 包含连接您的 Zendesk 所需的键值对的 AWS Secrets Manager 密钥的亚马逊资源名称 (ARN)。密钥必须包含具有以下键的 JSON 结构：主机 URL、客户端 ID、客户端密钥、用户名和密码。 | 
| additionalProperties | 数据来源中内容的其他配置选项 | 
| organizationNameFilter | 您可以选择为特定组织中存在的工单编制索引。 | 
| sinceDate | 您可以选择配置一个 sinceDate 参数，以便 Zendesk 连接器根据特定的 sinceDate 爬取内容。 | 
| inclusionPatterns | 用于在 Zendesk 数据来源中包含某些文件的正则表达式模式的列表。与模式匹配的文件将包含在索引中。与模式不匹配的文件将从索引中排除。如果文件同时匹配包含和排除模式，则以排除模式为优先，该文件不会包含在索引中。 | 
| exclusionPatterns | 用于在 Zendesk 数据来源中排除某些文件的正则表达式模式的列表。与模式匹配的文件将从索引中排除。与模式不匹配的文件将包含在索引中。如果文件同时匹配排除和包含模式，则以排除模式为优先，该文件不会包含在索引中。 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/ds-schemas.html)  | 输入“true”，以爬取这些类型的内容。 | 
| 类型 | 指定 ZENDESK 作为数据来源类型。 | 
| useChangeLog | 输入“true”，以使用 Zendesk 更改日志来确定需要在索引中更新的文档。根据更改日志的大小，在 Zendesk 中扫描文档可能会更快。如果您是首次将 Zendesk 数据来源与索引同步，则会扫描所有文档。 | 

### Zendesk JSON 架构
<a name="zendesk-json"></a>

```
{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "connectionConfiguration": {
      "type": "object",
      "properties": {
        "repositoryEndpointMetadata": {
          "type": "object",
          "properties": {
            "hostUrl": {
              "type": "string",
              "pattern": "https:.*"
            }
          },
          "required": [
            "hostUrl"
          ]
        }
      },
      "required": [
        "repositoryEndpointMetadata"
      ]
    },
    "repositoryConfigurations": {
      "type": "object",
      "properties": {
        "ticket": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"

                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "ticketComment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"

                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "ticketCommentAttachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "article": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "communityPostComment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "articleComment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "articleAttachment": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        },
        "communityTopic": {
          "type": "object",
          "properties": {
            "fieldMappings": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "object",
                    "properties": {
                      "indexFieldName": {
                        "type": "string"
                      },
                      "indexFieldType": {
                        "type": "string",
                        "enum": ["STRING", "STRING_LIST", "LONG", "DATE"]
                      },
                      "dataSourceFieldName": {
                        "type": "string"
                      },
                      "dateFieldFormat": {
                        "type": "string",
                        "pattern": "dd-MM-yyyy HH:mm:ss"
                      }
                    },
                    "required": [
                      "indexFieldName",
                      "indexFieldType",
                      "dataSourceFieldName"
                    ]
                  }
                ]
              }
            }
          },
          "required": [
            "fieldMappings"
          ]
        }
      }
    },
    "secretArn": {
      "type": "string",
      "minLength": 20,
      "maxLength": 2048
    },
    "additionalProperties": {
      "type": "object",
      "properties": {
        "organizationNameFilter": {
          "type": "array"
        },
        "sinceDate": {
          "type": "string",
          "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}$"
        },
        "inclusionPatterns": {
          "type": "array"
        },
        "exclusionPatterns": {
          "type": "array"
        },
        "isCrawTicket": {
          "type": "string"
        },
        "isCrawTicketComment": {
          "type": "string"
        },
        "isCrawTicketCommentAttachment": {
          "type": "string"
        },
        "isCrawlArticle": {
          "type": "string"
        },
        "isCrawlArticleAttachment": {
          "type": "string"
        },
        "isCrawlArticleComment": {
          "type": "string"
        },
        "isCrawlCommunityTopic": {
          "type": "string"
        },
        "isCrawlCommunityPost": {
          "type": "string"
        },
        "isCrawlCommunityPostComment": {
          "type": "string"
        }
      }
    },
    "type": {
      "type": "string",
      "pattern": "ZENDESK"
    },
    "useChangeLog": {
      "type": "string",
      "enum": ["true", "false"]
    }
  },
  "version": {
    "type": "string",
    "anyOf": [
      {
        "pattern": "1.0.0"
      }
    ]
  },
  "additionalProperties": false,
  "required": [
    "connectionConfiguration",
    "repositoryConfigurations",
    "additionalProperties",
    "useChangeLog",
    "secretArn",
    "type"
  ]
}
```

# Adobe Experience Manager
<a name="data-source-aem"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍将为现有客户提供对 Adobe Experience Manager 连接器的完全支持。该连接器虽已不再面向新用户开放，但现有用户可继续无中断使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Adobe Experience Manager 是一个用于创建网站或移动应用程序内容的内容管理系统。您可以使用Amazon Kendra连接到您的页面Adobe Experience Manager和内容资产并为其编制索引。

Amazon Kendra支持 Adobe Experience Manager (AEM) 作为云服务作者实例以及Adobe Experience Manager本地作者和发布实例。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)或 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Adobe Experience Manager数据源。

有关 Amazon Kendra Adobe Experience Manager 数据源连接器的疑难解答，[数据来源故障排除](troubleshooting-data-sources.md)

**Topics**
+ [支持的功能](#supported-features-aem)
+ [先决条件](#prerequisites-aem)
+ [连接说明](#data-source-procedure-aem)

## 支持的功能
<a name="supported-features-aem"></a>

Adobe Experience Manager 数据来源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ OAuth 2.0 和基本身份验证
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-aem"></a>

在使用索Amazon Kendra引Adobe Experience Manager数据源之前，请在Adobe Experience Manager和AWS帐户中进行这些更改。

**在 Adobe Experience Manager 中，请确保：**
+ 可访问具有管理权限的账户或管理员用户。
+ 已复制您的 Adobe Experience Manager 主机 URL。
**注意**  
（本地/服务器）Amazon Kendra会检查中AWS Secrets Manager包含的端点信息是否与数据源配置详细信息中指定的端点信息相同。这有助于防止出现[混淆代理人问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)，这是一个安全问题，即用户无权执行操作，但可以将 Amazon Kendra 作为代理来访问配置的密钥和执行操作。如果以后更改端点信息，则必须创建一个新密钥来同步此信息。
+ 记下您的管理员用户名和密码的基本身份验证凭证。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **可选**：在 Adobe Experience Manager (AEM) 中将 OAuth 2.0 凭据配置为云服务或 AEM 内部部署。如果您使用 AEM On-Premise，则凭证包括客户端 ID、客户端密钥和私有密钥。如果您使用 AEM 即云服务，则凭证包括客户端 ID、客户端密钥、私有密钥、组织 ID、技术账户 ID 和 Adobe Identity Management System（IMS）主机。有关如何为 AEM 即云服务生成这些凭证的更多信息，请参阅 [Adobe Experience Manager 文档](https://experienceleague.adobe.com/docs/experience-manager-learn/getting-started-with-aem-headless/authentication/service-credentials.html)。对于 AEM 本地部署，Adobe G OAuth ranite 2.0 服务器实现 (com.adobe.granite.oauth.server) 支持 AEM OAuth 中的 2.0 服务器功能。
+ 在 Adobe Experience Manager 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Adobe Experience Manager 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Adobe Experience Manager 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-aem"></a>

要Amazon Kendra连接到您的Adobe Experience Manager数据源，您必须提供Adobe Experience Manager数据源的必要详细信息，以便Amazon Kendra能够访问您的数据。如果您尚未进行配置Amazon Kendra，Adobe Experience Manager请参阅[先决条件](#prerequisites-aem)。

------
#### [ Console ]

**要连接Amazon Kendra到 Adobe Experience Manager** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Adobe Experience Manager 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Adobe Experience Manager 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **源** - 选择 **AEM On-Premise** 或 **AEM 即云服务**。

      输入您的 Adobe Experience Manager 主机 URL。例如，如果您使用 AEM On-Premise，则需要包含主机名和端口：*https://hostname:port*。或者，如果您使用 AEM 即云服务，则可以使用作者 URL：*https://author-xxxxxx-xxxxxxx.adobeaemcloud.com*。

   1. **SSL 证书位置** - 输入您存储在 Amazon S3 存储桶中的 SSL 证书的路径。您可以通过安全 SSL 连接使用它连接到 AEM On-Premise。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证**-选择**基本身份验证**或 **OAuth 2.0 身份验证**。然后选择现有AWS Secrets Manager密钥或创建新密钥来存储您的Adobe Experience Manager凭据。如果您选择创建新密钥，则会打开一个AWS Secrets Manager秘密窗口。

      如果选择**基本身份验证**，请输入密钥的名称、Adobe Experience Manager 站点用户名和密码。用户必须具有管理员权限或是管理员用户。

      如果您选择 **OAuth 2.0 身份验证**并使用 AEM On-Premise，请输入密钥的名称、客户端 ID、客户端密钥和私钥。如果您使用 AEM 即云服务，请输入密钥的名称、客户端 ID、客户端密钥、私有密钥、组织 ID、技术账户 ID 和 Adobe Identity Management System（IMS）主机。

      保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **同步范围** - 设置爬取某些内容类型、页面组件和根路径的限制，并使用正则表达式模式筛选内容。

      1. **内容类型** - 选择是仅爬取页面或资产，还是同时爬取两者。

      1. （可选）**其他配置** - 配置以下设置：
         + **页面组件** - 页面组件的特定名称。页面组件是一个可扩展的页面组件，旨在与Adobe Experience Manager模板编辑器配合使用，允许使用模板编辑器组装页面 header/footer 和结构组件。
         + **内容片段变体** - 内容片段变体的具体名称。内容片段允许您在 Adobe Experience Manager 中设计、创建、策划和发布与页面无关的内容。它们允许您准备内容，以备在 locations/over 多个渠道中使用。
         + **根路径** - 指向特定内容的根路径。
         + **正则表达式模式** - 包含或排除某些文件的正则表达式模式。

   1. **同步模式** - 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. **时区 ID** - 如果您使用 AEM On-Premise，并且服务器的时区与 AEM 连接器或索引的时区不同，则可以指定与 Amazon Kendra AEM 连接器或索引相符的服务器时区。AEM On-Premise 的默认时区是 Amazon Kendra AEM 连接器或索引的时区。AEM 即云服务的默认时区是格林威治标准时间。

   1. **同步运行计划**，对于**频率** – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。要添加自定义数据来源字段，请创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Adobe Experience Manager**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-aem-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `AEM`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **AEM 主机 URL** - 指定 Adobe Experience Manager 主机 URL。例如，如果您使用 AEM On-Premise，则需要包含主机名和端口：*https://hostname:port*。或者，如果您使用 AEM 即云服务，则可以使用作者 URL：*https://author-xxxxxx-xxxxxxx.adobeaemcloud.com*。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **身份验证类型** - 指定要使用的身份验证类型，可以是 `Basic` 或 `OAuth2`。
+ **AEM 类型** - 指定您使用的 Adobe Experience Manager 类型，可以是 `CLOUD` 或 `ON_PREMISE`。
+ **密钥 Amazon 资源名称（ARN）**- 如果您想对 AEM 本地或云端使用基本身份验证，则需要提供一个用于存储您的用户名和密码的身份验证凭证的密钥。您提供密钥的 Amazon 资源名称 (ARN)。AWS Secrets Manager密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "aemUrl": "Adobe Experience Manager On-Premise host URL",
      "username": "user name with admin permissions",
      "password": "password with admin permissions"
  }
  ```

  如果您想对 AEM On-Premise 使用 OAuth 2.0 身份验证，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "aemUrl": "Adobe Experience Manager host URL",
      "clientId": "client ID",
      "clientSecret": "client secret",
      "privateKey": "private key"
  }
  ```

  如果您想将 AEM 作为云服务使用 OAuth 2.0 身份验证，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "clientId": "client ID",
      "clientSecret": "client secret",
      "privateKey": "private key",
      "orgId": "organization ID",
      "technicalAccountId": "technical account ID",
      "imsHost": "Adobe Identity Management System (IMS) host"
  }
  ```
+ **IAM角色**-指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及致电 Adobe Experience Manager 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Adobe Experience Manager 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **时区 ID**-如果您使用 AEM 本地部署，并且服务器的时区与 AEM 连接器或索引的时区不同，则可以指定与 Amazon Kendra AEM 连接器或索引对齐的服务器时区。

  AEM 本地部署的默认时区是 AE Amazon Kendra M 连接器或索引的时区。AEM 即云服务的默认时区是格林威治标准时间。

  有关支持的时区的信息 IDs，请参阅 [Adobe Experience ManagerJSON 架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#aem-json)。
+ **包含和排除筛选条件** - 指定是包含还是排除页面和资产。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Adobe Experience Manager 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Adobe Experience Manager 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-aem-schema)。

------

# Alfresco
<a name="data-source-alfresco"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍将为现有客户提供对 Alfresco 连接器的完全支持。该连接器虽已不再面向新用户开放，但现有用户可继续无中断使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Alfresco 是一项内容管理服务，可帮助客户存储和管理其内容。您可以使用索引Amazon Kendra您的Alfresco文档库、Wiki 和博客。

Amazon Kendra支持Alfresco本地部署和Alfresco云端（平台即服务）。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)或 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Alfresco数据源。

要对 Amazon Kendra Alfresco 数据源连接器进行故障排除，请参阅。[数据来源故障排除](troubleshooting-data-sources.md)

**Topics**
+ [支持的功能](#supported-features-alfresco)
+ [先决条件](#prerequisites-alfresco)
+ [连接说明](#data-source-procedure-alfresco)
+ [了解详情](#alfresco-learn-more)

## 支持的功能
<a name="supported-features-alfresco"></a>

Amazon KendraAlfresco 数据来源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ OAuth 2.0 和基本身份验证
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-alfresco"></a>

在使用Amazon Kendra索引 Alfresco 数据源之前，请在和中进行这些更改。Alfresco AWS 账户

**在 Alfresco 中，请确保：**
+ 已复制您的 Alfresco 存储库 URL 和 Web 应用程序 URL。如果您只想为特定 Alfresco 站点编制索引，则还要复制该站点 ID。
+ 已记下您的 Alfresco 身份验证凭证，其中包括至少具有读取权限的用户名和密码。如果要使用 OAuth 2.0 身份验证，则应将用户添加到Alfresco管理员组。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **可选**：已在中配置 OAuth 2.0 凭据Alfresco。这些凭证包括客户端 ID、客户端密钥和令牌 URL。有关如何为 Alfresco On-Premises 配置客户端的更多信息，请参阅 [Alfresco 文档](https://docs.alfresco.com/identity-service/latest/tutorial/sso/saml/)。如果您使用 Alfresco Cloud (PaaS)，则必须联系 [Hyland 支持](https://community.hyland.com/)人员进行 Alfresco OAuth 2.0 身份验证。
+ 在 Alfresco 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Alfresco 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Alfresco 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥。Amazon Kendra如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-alfresco"></a>

要Amazon Kendra连接到您的 Alfresco 数据源，您必须提供 Alfresco 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Alfresco 配置Amazon Kendra，请参阅。[先决条件](#prerequisites-alfresco)

------
#### [ Console ]

**要连接Amazon Kendra到 Alfresco**

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Alfresco 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Alfresco 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Alfresco 类型** - 选择使用 Alfresco 本地部署/服务器，还是 Alfresco 云（平台即服务）。

   1. **Alfresco 存储库 URL** - 输入您的 Alfresco 存储库 URL。例如，如果您使用 Alfresco Cloud（PaaS），则存储库 URL 可能是 *https://company.alfrescocloud.com*。或者，如果您使用 Alfresco On-Premises，则存储库 URL 可能是 *https://company-alfresco-instance.company-domain.suffix:port*。

   1. **Alfresco 用户应用程序。URL** - 输入您的 Alfresco 用户界面 URL。您可以向 Alfresco 管理员获取存储库 URL。例如，用户界面 URL 可能是 *https://example.com*。

   1. **SSL 证书位置**-输入存储在存储Amazon S3桶中的 SSL 证书的路径。您可以通过安全 SSL 连接使用它连接到 Alfresco 本地部署。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证**-选择**基本身份验证**或 **OAuth 2.0 身份验证**。然后选择现有 Secrets Manager 密钥或创建新密钥来存储您的 Alfresco 凭证。如果您选择创建新密钥，则会打开一个AWS Secrets Manager秘密窗口。

      如果选择**基本身份验证**，请输入密钥的名称、Alfresco 用户名和密码。

      如果您选择 **OAuth 2.0 身份验证**，请输入密钥的名称、客户端 ID、客户端密钥和令牌 URL。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **同步范围** - 设置爬取某些内容的限制，并使用正则表达式模式筛选内容。

   1. 

      1. **内容** - 选择是爬取 Alfresco 中标有“方面”的内容、特定 Alfresco 站点内的内容还是所有 Alfresco 站点内的内容。

      1. （可选）**其他配置** - 设置以下设置：
         + **包括评论** - 选择在 Alfresco 文档库和博客中包含评论。
         + **正则表达式模式** - 包含或排除某些文件的正则表达式模式。

   1. **同步模式** - 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1. 要添加自定义数据来源字段，请创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Alfresco**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-alfresco-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `ALFRESCO`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **Alfresco 站点 ID** - 指定 Alfresco 站点 ID。
+ **Alfresco 存储库 URL** - 指定 Alfresco 存储库 URL。您可以向 Alfresco 管理员获取存储库 URL。例如，如果您使用 Alfresco Cloud（PaaS），则存储库 URL 可能是 *https://company.alfrescocloud.com*。或者，如果您使用 Alfresco On-Premises，则存储库 URL 可能是 *https://company-alfresco-instance.company-domain.suffix:port*。
+ **Alfresco Web 应用程序 URL** - 指定 Alfresco 用户界面 URL。您可以向 Alfresco 管理员获取存储库 URL。例如，用户界面 URL 可能是 *https://example.com*。
+ **身份验证类型** - 指定要使用的身份验证类型，可以是 `OAuth2` 或 `Basic`。
+ **Alfresco 类型** - 指定您使用的 Alfresco 类型，可以是 `PAAS`（云/平台即服务）或 `ON_PREM`（本地部署）。
+ **密钥 Amazon 资源名称（ARN）**- 如果您想使用基本身份验证，则需要提供一个用于存储您的用户名和密码的身份验证凭证的密钥。您提供密钥的亚马逊资源名称 (ARN)。AWS Secrets Manager密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "username": "user name",
      "password": "password"
  }
  ```

  如果要使用 OAuth 2.0 身份验证，则密钥存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "clientId": "client ID",
      "clientSecret": "client secret",
      "tokenUrl": "token URL"
  }
  ```
+ **IAMrole** —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及呼叫 Alfresco 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Alfresco 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **内容类型** - 您要爬取的内容类型，无论是 Alfresco 中标有“方面”的内容、特定 Alfresco 站点内的内容，还是所有 Alfresco 站点内的内容。您还可以列出特定的“方面”内容。
+ **包含和排除筛选条件** - 指定是包含还是排除文件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **身份爬网程序** - 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Alfresco 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Alfresco 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-alfresco-schema)。

------

## 了解详情
<a name="alfresco-learn-more"></a>

要了解有关Amazon Kendra与 Alfresco 数据源集成的更多信息，请参阅：
+ [使用智能搜索Alfresco内容 Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/intelligently-search-alfresco-content-using-amazon-kendra/)

# Aurora(MySQL)
<a name="data-source-aurora-mysql"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Aurora(MySQL) 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Aurora是专为云构建的关系数据库管理系统 (RDBMS)。如果您是Aurora用户，则可以使用索Amazon Kendra引您的Aurora(MySQL)数据源。Amazon KendraAurora(MySQL)数据源连接器支持 Aurora MySQL 3 和Aurora无服务器 MySQL 8.0。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Aurora(MySQL)数据源。

要对Amazon KendraAurora(MySQL)数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-aurora-mysql)
+ [先决条件](#prerequisites-aurora-mysql)
+ [连接说明](#data-source-procedure-aurora-mysql)
+ [注意](#aurora-mysql-notes)

## 支持的功能
<a name="supported-features-aurora-mysql"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-aurora-mysql"></a>

在使用索Amazon Kendra引Aurora(MySQL)数据源之前，请在Aurora(MySQL)和AWS帐户中进行这些更改。

**在 Aurora(MySQL) 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。你可以在Amazon RDS控制台上找到这些信息。
+ 在 Aurora(MySQL) 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Aurora(MySQL) 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Aurora(MySQL)数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-aurora-mysql"></a>

要Amazon Kendra连接到您的Aurora(MySQL)数据源，您必须提供Aurora(MySQL)凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，Aurora(MySQL)请参Amazon Kendra阅[先决条件](#prerequisites-aurora-mysql)。

------
#### [ Console ]

**要连接Amazon Kendra到 Aurora(MySQL)** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Aurora(MySQL) 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Aurora(MySQL) 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** – 输入数据库主机 URL，例如：`http://instance URL.region.rds.amazonaws.com`。

   1.  **端口** –输入数据库端口，例如 `5432`。

   1.  **实例** - 输入数据库实例。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的Aurora(MySQL)身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Aurora(MySQL)-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB SQL 查询必须小于 32KB 且不包含任何分号 (;)。 Amazon Kendra将抓取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + “用户 ** IDs” 列**-输入包含 IDs 要允许访问内容的用户的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（“文档” IDs、“**文档****标题**” 和 “**来源**” URLs）中进行选择，以映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Aurora(MySQL)**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `mySql`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。Aurora(MySQL)密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Aurora(MySQL)连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Aurora(MySQL) S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Aurora(MySQL) 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Aurora (MySQL) 模板架构](ds-schemas.md#ds-aurora-mysql-schema)。

------

## 注意
<a name="aurora-mysql-notes"></a>
+ Amazon Kendra检查已更新的内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Aurora(PostgreSQL)
<a name="data-source-aurora-postgresql"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Aurora(PostgreSQL) 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Aurora是专为云构建的关系数据库管理系统 (RDBMS)。如果您是Aurora用户，则可以使用索Amazon Kendra引您的Aurora(PostgreSQL)数据源。Amazon KendraAurora(PostgreSQL)数据源连接器支持 Aurora PostgreSQL 1。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Aurora(PostgreSQL)数据源。

要对Amazon KendraAurora(PostgreSQL)数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-aurora-postgresql)
+ [先决条件](#prerequisites-aurora-postgresql)
+ [连接说明](#data-source-procedure-aurora-postgresql)
+ [注意](#aurora-postgresql-notes)

## 支持的功能
<a name="supported-features-aurora-postgresql"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-aurora-postgresql"></a>

在使用索Amazon Kendra引Aurora(PostgreSQL)数据源之前，请在Aurora(PostgreSQL)和AWS帐户中进行这些更改。

**在 Aurora(PostgreSQL) 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 在 Aurora(PostgreSQL) 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Aurora(PostgreSQL) 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Aurora(PostgreSQL)数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-aurora-postgresql"></a>

要Amazon Kendra连接到您的Aurora(PostgreSQL)数据源，您必须提供Aurora(PostgreSQL)凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，Aurora(PostgreSQL)请参Amazon Kendra阅[先决条件](#prerequisites-aurora-postgresql)。

------
#### [ Console ]

**要连接Amazon Kendra到 Aurora(PostgreSQL)** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Aurora(PostgreSQL) 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Aurora(PostgreSQL) 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** – 输入数据库主机 URL，例如：`http://instance URL.region.rds.amazonaws.com`。

   1.  **端口** –输入数据库端口，例如 `5432`。

   1.  **实例** – 输入数据库实例，例如 `postgres`。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的Aurora(PostgreSQL)身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Aurora(PostgreSQL)-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB SQL 查询必须小于 32KB 且不包含任何分号 (;)。 Amazon Kendra将抓取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + “用户 ** IDs” 列**-输入包含 IDs 要允许访问内容的用户的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（**文档 IDs**、**文档标题**和**来源 URLs**）中选择要映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Aurora(PostgreSQL)**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `postgresql`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。Aurora(PostgreSQL)密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Aurora(PostgreSQL)连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Aurora(PostgreSQL) S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Aurora(PostgreSQL) 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Aurora (PostgreSQL) 模板架构](ds-schemas.md#ds-aurora-postgresql-schema)。

------

## 注意
<a name="aurora-postgresql-notes"></a>
+ 在Amazon Kendra检查更新内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Amazon FSx（视窗）
<a name="data-source-fsx"></a>

Amazon FSx(Windows) 是一个完全托管的、基于云的文件服务器系统，提供共享存储功能。如果你是 Amazon FSx (Windows) 用户，则可以使用Amazon Kendra索引你的 Amazon FSx (Windows) 数据源。

**注意**  
Amazon Kendra现在支持升级版 Amazon FSx (Windows) 连接器。  
已为您自动完成控制台升级。您在控制台中新建的所有连接器都将使用升级后的架构。现在，如果您使用 API，则必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象而不是 `FSxConfiguration` 对象来配置您的连接器。  
使用旧版控制台和 API 架构配置的连接器仍可照常运行，但您将无法编辑或更新它们。如果要编辑或更新连接器配置，必须新建一个连接器。  
我们建议您将连接器工作流程迁移至升级后的版本。使用旧版架构配置的连接器的支持预计将在 2024 年 6 月前终止。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)或 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Amazon FSx (Windows) 数据源。

要对您的 Amazon Kendra Amazon FSx (Windows) 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-fsx)
+ [先决条件](#prerequisites-fsx)
+ [连接说明](#data-source-procedure-fsx)
+ [了解详情](#fsx-learn-more)

## 支持的功能
<a name="supported-features-fsx"></a>

Amazon KendraAmazon FSx(Windows) 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 用户身份爬取
+ 包含和排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-fsx"></a>

在使用Amazon Kendra索引 Amazon FSx (Windows) 数据源之前，请先检查您的 Amazon FSx (Windows) 和的详细信息AWS 账户。

**对于 Amazon FSx (Windows)，请确保你有**：
+ 使用读取和装载权限进行设置 Amazon FSx (Windows)。
+ 已记下您的文件系统 ID。您可以在 Amazon FSx (Windows) 控制台的 “文件系统” 仪表板上找到您的文件系统 ID。
+ 使用您的 Amazon FSx (Windows) 文件系统所在Amazon VPC位置配置虚拟私有云。
+ 记下了你的 Amazon FSx (Windows) Active Directory 用户帐户身份验证凭证。这包括您的 Active Directory 用户名、DNS 域名（例如，*user@corp.example.com*）和密码。
**注意**  
仅使用连接器运行所需的必要凭证。请勿使用诸如域管理员之类的特权凭证。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 已选中每个文档在 Amazon FSx (Windows) 中以及计划用于同一索引的其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将你的 Amazon FSx (Windows) 身份验证凭证存储在AWS Secrets Manager密钥中，如果使用 API，则记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Amazon FSx (Windows) 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-fsx"></a>

要Amazon Kendra连接到您的 Amazon FSx (Windows) 数据源，必须提供您的 Amazon FSx (Windows) 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未配置 Amazon FSx (Windows)Amazon Kendra，请参阅[先决条件](#prerequisites-fsx)。

------
#### [ Console ]

**Amazon Kendra连接到你的 Amazon FSx (Windows) 文件系统** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Amazon FSx（Windows）连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Amazon FSx（Windows）连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Amazon FSx(Windows) 文件系统 ID**-从下拉列表中选择从 Amazon FSx (Windows) 获取的现有文件系统 ID。或者，创建一个 [Amazon FSx（Windows）文件系统](https://console.aws.amazon.com/fsx/)。您可以在 Amazon FSx (Windows) 控制台的 “文件系统” 仪表板上找到您的文件系统 ID。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证**-选择现有AWS Secrets Manager密钥，或创建新密钥来存储您的文件系统凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      提供存储身份验证凭证（用户名和密码）的密钥。用户名必须包含您的 DNS 域名。例如，*user@corp.example.com*。

      保存并添加您的密钥。

   1. **虚拟私有云 (VPC)** — 你必须选择Amazon VPC你的 (Windows) Amazon FSx 所在的位置。您可以包含 VPC 子网和安全组。请参阅[配置Amazon VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **同步范围、正则表达式模式** - 添加包含或排除某些文件的正则表达式模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. **同步运行计划** – 对于**频率**，选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从Amazon Kendra生成的文件默认字段中选择要映射到索引的字段。要添加自定义数据来源字段，请创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**Amazon Kendra连接到你的 Amazon FSx (Windows) 文件系统**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-fsx-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `FSX`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **文件系统 ID**-Amazon FSx (Windows) 文件系统的标识符。您可以在 Amazon FSx（Windows）控制台的文件系统控制面板上找到文件系统 ID。
+ **文件系统类型** - 将文件系统的类型指定为 `WINDOWS`。
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
**注意**  
你必须选择你的 Amazon FSx (Windows) 所在的位置。Amazon VPC您可以包含 VPC 子网和安全组。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **身份爬网程序** - 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您 Amazon FSx (Windows) 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "username": "user@corp.example.com",
      "password": "password"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用 Amazon FSx (Windows) 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Amazon FSx(Windows) 数据源的IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **包含和排除筛选条件** - 指定是包含还是排除文件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **访问控制列表（ACL）**- 如果您有 ACL 并想将其用于访问控制，请选择是否爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。
**注意**  
要对用户测试用户上下文筛选，在发出查询时，必须将 DNS 域名作为用户名的一部分包含在内。您必须拥有 Active Directory 域的管理权限。您也可以根据组名称测试用户上下文筛选。
+  **字段映射**-选择将您的 Amazon FSx (Windows) 数据源字段映射到Amazon Kendra索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Amazon FSx（Windows）模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-fsx-windows-schema)。

------

## 了解详情
<a name="fsx-learn-more"></a>

要了解有关Amazon Kendra与你的 Amazon FSx (Windows) 数据源集成的更多信息，请参阅：
+ [使用 Amazon FSx (Windows) 的Amazon Kendra连接器，安全地搜索 Windows 文件系统上的非结构化数据。Windows File Server](https://aws.amazon.com/blogs/machine-learning/securely-search-unstructured-data-on-windows-file-systems-with-amazon-kendra-connector-for-amazon-fsx-for-windows-file-server/)

# Amazon FSx（NetApp ONTAP）
<a name="data-source-fsx-ontap"></a>

Amazon FSx(NetApp ONTAP) 是一个完全托管的、基于云的文件服务器系统，提供共享存储功能。如果您是 Amazon FSx (NetApp ONTAP) 用户，则可以使用Amazon Kendra索引您的 Amazon FSx (NetApp ONTAP) 数据源。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)或 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Amazon FSx (NetApp ONTAP) 数据源。

要对您的 Amazon Kendra Amazon FSx (NetApp ONTAP) 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-fsx-ontap)
+ [先决条件](#prerequisites-fsx-ontap)
+ [连接说明](#data-source-procedure-fsx-ontap)

## 支持的功能
<a name="supported-features-fsx-ontap"></a>

Amazon KendraAmazon FSx(NetApp ONTAP) 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含和排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-fsx-ontap"></a>

在使用Amazon Kendra索引 Amazon FSx (NetApp ONTAP) 数据源之前，请先检查您的 Amazon FSx (NetApp ONTAP) 和的详细信息。AWS 账户

**对于 Amazon FSx (NetApp ONTAP)，请确保您具有**：
+ 使用读取和挂载权限进行设置 Amazon FSx (NetApp ONTAP)。
+ 已记下您的文件系统 ID。您可以在 Amazon FSx (NetApp ONTAP) 控制台的文件系统控制面板上找到您的文件系统 ID。
+ 已记下用于您文件系统的存储虚拟机（SVM）ID。您可以前往 Amazon FSx (NetApp ONTAP) 控制台中的文件系统仪表板，选择您的文件系统 ID，然后选择**存储虚拟**机，找到您的 SVM ID。
+ 使用您的 Amazon FSx (NetApp ONTAP) 文件系统所在Amazon VPC位置配置虚拟私有云。
+ 记下您的 Amazon FSx (NetApp ONTAP) Active Directory 用户帐户身份验证凭据。这包括您的 Active Directory 用户名、DNS 域名（例如，*user@corp.example.com*）和密码。如果您的 (NetApp ONTAP) 文件系统使用网络文件系统 Amazon FSx (NFS) 协议，则身份验证凭据包括左 ID、右 ID 和预共享密钥。
**注意**  
仅使用连接器运行所需的必要凭证。请勿使用诸如域管理员之类的特权凭证。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 已选中每个文档在 Amazon FSx (NetApp ONTAP) 中以及计划用于同一索引的其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Amazon FSx (NetApp ONTAP) 身份验证凭据存储在AWS Secrets Manager密钥中，如果使用 API，则记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Amazon FSx (NetApp ONTAP) 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-fsx-ontap"></a>

要Amazon Kendra连接到您的Amazon FSx（NetApp ONTAP）数据源，您必须提供您的Amazon FSx（NetApp ONTAP）数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未配置 Amazon FSx (NetApp ONTAP)Amazon Kendra，请参阅[先决条件](#prerequisites-fsx-ontap)。

------
#### [ Console ]

**Amazon Kendra连接到您的 Amazon FSx (NetApp ONTAP) 文件系统** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据源**页面上，选择 **Amazon FSx(NetApp ONTAP) 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有 “V2.0” 标签的 **Amazon FSx(NetApp ONTAP) 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **来源** – 提供您的文件系统信息。
      + **文件系统协议**-选择您的 Amazon FSx (NetApp ONTAP) 文件系统的协议。您可以选择通用互联网文件系统（CIFS）协议，也可以选择适用于 Linux 的网络文件系统（NFS）协议。
      + **Amazon FSx(NetApp ONTAP) 文件系统 ID**-从下拉列表中选择从中获取的现有文件系统 ID Amazon FSx (NetApp ONTAP)。或者，创建 [Amazon FSx(NetApp ONTAP) 文件系统](https://console.aws.amazon.com/fsx/)。您可以在 Amazon FSx (NetApp ONTAP) 控制台的文件系统控制面板上找到您的文件系统 ID。
      + **SVM ID**Amazon FSx（NetApp ONTAP仅限 NetApp ONTAP）-提供您Amazon FSx的（ONTAP）的存储虚拟机 (SVM) ID（ONTAP）。NetApp NetApp ONTAP您可以前往 Amazon FSx (NetApp ONTAP) 控制台中的文件系统仪表板，选择您的文件系统 ID，然后选择**存储虚拟**机，找到您的 SVM ID。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证**-选择现有AWS Secrets Manager密钥，或创建新密钥来存储您的文件系统凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      提供存储身份验证凭证（用户名和密码）的密钥。用户名必须包含您的 DNS 域名。例如，*user@corp.example.com*。

      如果您的 Amazon FSx (NetApp ONTAP) 文件系统使用 NFS 协议，请提供一个密钥来存储您的身份验证凭据，包括左 ID、右 ID 和预共享密钥。

      保存并添加您的密钥。

   1. **虚拟私有云 (VPC)**-您必须选择您的 NetApp (ONTA Amazon VPC P) Amazon FSx 所在的位置。您可以包含 VPC 子网和安全组。请参阅[配置Amazon VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **同步范围、正则表达式模式** - 添加包含或排除某些文件的正则表达式模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. **同步运行计划** – 对于**频率**，选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从Amazon Kendra生成的文件默认字段中选择要映射到索引的字段。要添加自定义数据来源字段，请创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**Amazon Kendra连接到您的 Amazon FSx (NetApp ONTAP) 文件系统**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-fsx-ontap-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `FSXONTAP`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **文件系统 ID**-Amazon FSx (NetApp ONTAP) 文件系统的标识符。您可以在 Amazon FSx (NetApp ONTAP) 控制台的文件系统控制面板上找到您的文件系统 ID。
+ **SVM ID** – 用于您文件系统的存储虚拟机（SVM）ID。您可以前往 Amazon FSx (NetApp ONTAP) 控制台中的文件系统仪表板，选择您的文件系统 ID，然后选择**存储虚拟**机，找到您的 SVM ID。
+ **协议类型** – 指定您是使用通用互联网文件系统（CIFS）协议还是使用适用于 Linux 的网络文件系统（NFS）协议。
+ **文件系统类型** – 将文件系统的类型指定为 `FSXONTAP`。
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
**注意**  
您必须选择您的 Amazon VPC Amazon FSx (NetApp ONTAP) 所在的位置。您可以包含 VPC 子网和安全组。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您 Amazon FSx (ONTAP) 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。NetApp 密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "username": "user@corp.example.com",
      "password": "password"
  }
  ```

  如果您的 Amazon FSx (NetApp ONTAP) 文件系统使用 NFS 协议，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "leftId": "left ID",
      "rightId": "right ID",
      "preSharedKey": "pre-shared key"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及呼叫 Amazon FSx (NetApp ONTAP) 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Amazon FSx(NetApp ONTAP) 数据源的IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **包含和排除筛选条件** - 指定是包含还是排除文件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **访问控制列表（ACL）**- 如果您有 ACL 并想将其用于访问控制，请选择是否爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。
**注意**  
要对用户测试用户上下文筛选，在发出查询时，必须将 DNS 域名作为用户名的一部分包含在内。您必须拥有 Active Directory 域的管理权限。您也可以根据组名称测试用户上下文筛选。
+  **字段映射**-选择将您的 Amazon FSx (NetApp ONTAP) 数据源字段映射到索引字段。Amazon Kendra有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 密钥的列表，请参阅 [Amazon FSx(NetApp ONTAP) 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-fsx-ontap-schema)。

------

# Amazon RDS/Aurora
<a name="data-source-database"></a>

您可以使用数据库数据来源为存储在数据库中的文档编制索引。提供数据库的连接信息后，Amazon Kendra连接和索引文档。

Amazon Kendra支持以下数据库：
+ Amazon Aurora MySQL
+ Amazon Aurora PostgreSQL
+ Amazon RDS适用于 MySQL
+ Amazon RDS适用于 PostgreSQL

**注意**  
不支持无服务器 Aurora 数据库。

**重要**  
这款 Amazon RDS/Aurora 连接器计划于 2023 年底之前弃用。  
Amazon Kendra现在支持新的数据库数据源连接器。为了改善体验，我们建议您选择以下适用于您的用例的新连接器：  
[Aurora(MySQL)](https://docs.aws.amazon.com/kendra/latest/dg/data-source-aurora-mysql.html)
[Aurora(PostgreSQL)](https://docs.aws.amazon.com/kendra/latest/dg/data-source-aurora-postgresql.html)
[Amazon RDS(MySQL)](https://docs.aws.amazon.com/kendra/latest/dg/data-source-rds-mysql.html)
[Amazon RDS（微软 SQL Server）](https://docs.aws.amazon.com/kendra/latest/dg/data-source-rds-ms-sql-server.html)
[Amazon RDS（甲骨文）](https://docs.aws.amazon.com/kendra/latest/dg/data-source-rds-oracle.html)
[Amazon RDS(PostgreSQL)](https://docs.aws.amazon.com/kendra/latest/dg/data-source-rds-postgresql.html)
[IBM DB2](https://docs.aws.amazon.com/kendra/latest/dg/data-source-ibm-db2.html)
[Microsoft SQL Server](https://docs.aws.amazon.com/kendra/latest/dg/data-source-ms-sql-server.html)
[MySQL](https://docs.aws.amazon.com/kendra/latest/dg/data-source-mysql.html)
[Oracle Database](https://docs.aws.amazon.com/kendra/latest/dg/data-source-oracle-database.html)
[PostgreSQL](https://docs.aws.amazon.com/kendra/latest/dg/data-source-postgresql.html)

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [DatabaseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DatabaseConfiguration.html)API Amazon Kendra 连接到数据库数据源。

要对Amazon Kendra数据库数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-database)
+ [先决条件](#prerequisites-database)
+ [连接说明](#data-source-procedure-database)

## 支持的功能
<a name="supported-features-database"></a>

Amazon Kendra数据库数据源连接器支持以下功能：
+ 字段映射
+ 用户上下文筛选
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-database"></a>

在使用Amazon Kendra索引数据库数据源之前，请先在数据库和AWS帐户中进行这些更改。

**在数据库中，请确保：**
+ 记下您的数据库用户名和密码基本身份验证凭证。
+ 已复制主机名、端口号、主机地址、数据库名称以及包含文档数据的数据表的名称。对于 PostgreSQL，数据表必须是公共表或公共架构。
**注意**  
主机和端口告诉您在 Internet 上的Amazon Kendra何处可以找到数据库服务器。数据库名和表名告诉你Amazon Kendra在数据库服务器上哪里可以找到文档数据。
+ 已复制数据表中包含文档数据的列的名称。必须包括文档 ID、文档正文、用于检测文档是否已更改的列（例如，上次更新的列）以及映射到自定义索引字段的可选数据表列。您也可以将任何 [Amazon Kendra 保留字段名称](https://docs.aws.amazon.com/kendra/latest/dg/hiw-document-attributes.html#index-reserved-fields)映射到表列。
+ 已复制数据库引擎类型信息，例如您使用的是 My Amazon RDS SQL 还是其他类型。
+ 在数据库以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的数据库身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将数据库数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-database"></a>

要Amazon Kendra连接到数据库数据源，必须提供数据库数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为配置数据库Amazon Kendra，请参见[先决条件](#prerequisites-database)。

------
#### [ Console ]

**Amazon Kendra连接到数据库** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择**数据库连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的**数据库连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **终端节点**-DNS 主机名、 IPv4 地址或 IPv6 地址。

   1. **端口** - 端口号。

   1. **数据库** - 数据库名称。

   1. **表名** - 表名。

   1. 对于**身份验证类型**，请选择**现有**或**新建**，以便存储您的数据库身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

        1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-database-” 会自动添加到您的密钥名称中。

        1. 对于**用户名**和**密码** - 输入您从数据库账户中复制的身份验证凭证值。

        1. 选择**保存身份验证**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。
**注意**  
您必须使用私有子网。如果您的 RDS 实例位于您的 VPC 的公有子网中，则可以创建一个私有子网，该子网可以出站访问公有子网中的 NAT 网关。VPC 配置中提供的子网必须位于美国西部（俄勒冈州）、美国东部（弗吉尼亚北部）和欧洲（爱尔兰）。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 根据您的使用案例，选择 **Aurora MySQL**、**MySQL**、**Aurora PostgreSQL** 和 **PostgreSQL**。

   1. **用双引号将 SQL 标识符括起来** - 选择使用双引号将 SQL 标识符括起来。例如，“columnName”。

   1. **ACL 列**和**变更检测列**-配置Amazon Kendra用于变更检测的列（例如，上次更新的列）和您的访问控制列表。

   1. 在 “**同步运行计划**” 中，“**频率**”-选择与数据源同步的频率。Amazon Kendra

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **Amazon Kendra默认字段映射**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。必须为 `document_id` 和 `document_body` 添加**数据库列**值 

   1.  **自定义字段映射** - 要添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**Amazon Kendra连接到数据库**

您必须指定以下 [DatabaseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DatabaseConfiguration.html)API：
+ **ColumnConfiguration**— 有关索引应从数据库中从何处获取文档信息的信息。有关更多详细信息，请参阅 [ColumnConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ColumnConfiguration.html)。必须指定 `DocumentDataColumnName`（文档正文或朱文本）、`DocumentIdColumnName` 和 `ChangeDetectingColumn`（例如，上次更新的列）字段。映射到 `DocumentIdColumnName` 字段的列必须是整数列。以下示例显示数据库数据来源的简单列配置：

  ```
  "ColumnConfiguration": {
      "ChangeDetectingColumns": [
          "LastUpdateDate",
          "LastUpdateTime"
      ],
      "DocumentDataColumnName": "TextColumn",
      "DocumentIdColumnName": "IdentifierColumn",
      "DocoumentTitleColumnName": "TitleColumn",
      "FieldMappings": [
          {
              "DataSourceFieldName": "AbstractColumn",
              "IndexFieldName": "Abstract"
          }
      ]
  }
  ```
+ **ConnectionConfiguration**— 连接数据库所需的配置信息。有关更多详细信息，请参阅 [ConnectionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ConnectionConfiguration.html)。
+ **DatabaseEngineType**— 运行数据库的数据库引擎的类型。的`DatabaseHost`字段`ConnectionConfiguration`必须是数据库的 Amazon Relational Database Service (Amazon RDS) 实例终端节点。不要使用集群端点。
+ **亚马逊秘密资源名称 (ARN)**-提供包含数据库账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "username": "user name",
      "password": "password"
  }
  ```

  以下示例显示数据库配置，包括密钥 ARN。

  ```
  "DatabaseConfiguration": {
  "ConnectionConfiguration": {
  "DatabaseHost": "host.subdomain.domain.tld",
          "DatabaseName": "DocumentDatabase",
          "DatabasePort": 3306,
          "SecretArn": "arn:aws:secretmanager:region:account ID:secret/secret name",
          "TableName": "DocumentTable"
      }
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用数据库连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅[数据库数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **虚拟私有云（VPC）**- 在数据来源配置中指定 `VpcConfiguration`。请参阅[配置 Amazon Kendra 以使用 VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。
**注意**  
您只能使用私有子网。如果您的 RDS 实例位于您的 VPC 的公有子网中，则可以创建一个私有子网，该子网可以出站访问公有子网中的 NAT 网关。VPC 配置中提供的子网必须位于美国西部（俄勒冈州）、美国东部（弗吉尼亚北部）和欧洲（爱尔兰）。
+  **字段映射** - 选择将数据库数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。

------

# Amazon RDS（微软 SQL Server）
<a name="data-source-rds-ms-sql-server"></a>

**注意**  
Amazon RDS（微软 SQL Server）连接器将在 2026 年 5 月 31 日之前完全支持现有客户。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

SQL Server 是由微软开发的数据库管理系统。 Amazon RDSfor SQL Server 可以轻松地在云中设置、操作和扩展 SQL Server 部署。如果你是Amazon RDS（微软 SQL Server）用户，则可以使用Amazon Kendra索引你的Amazon RDS（微软 SQL Server）数据源。Amazon KendraJDBC 数据源连接器支持微软 SQL Server 2019。

你可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到你的Amazon RDS（微软 SQL Server）数据源。

要对你的 Amazon KendraAmazon RDS（微软 SQL Server）数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-rds-ms-sql-server)
+ [先决条件](#prerequisites-rds-ms-sql-server)
+ [连接说明](#data-source-procedure-rds-ms-sql-server)
+ [注意](#rds-ms-sql-server-notes)

## 支持的功能
<a name="supported-features-rds-ms-sql-server"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-rds-ms-sql-server"></a>

在使用Amazon Kendra索引你的Amazon RDS（微软 SQL Server）数据源之前，请在你的Amazon RDS（微软 SQL Server）和AWS账户中进行这些更改。

**在Amazon RDS（微软 SQL Server）中，确保你有：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 已检查每个文档在Amazon RDS（Microsoft SQL Server）以及计划用于同一索引的其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将你的Amazon RDS（Microsoft SQL Server）身份验证凭据存储在AWS Secrets Manager密钥中，如果使用 API，则记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Amazon RDS（Microsoft SQL Server）数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-rds-ms-sql-server"></a>

Amazon Kendra要连接到你的Amazon RDS（微软 SQL Server）数据源，你必须提供你的Amazon RDS（微软 SQL Server）凭据的详细信息，这样Amazon Kendra才能访问你的数据。如果你尚未配置Amazon RDS（Microsoft SQL Server），Amazon Kendra请参阅[先决条件](#prerequisites-rds-ms-sql-server)。

------
#### [ Console ]

**要连接Amazon Kendra到Amazon RDS（微软 SQL Server）** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Amazon RDS（Microsoft SQL Server）连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Amazon RDS（Microsoft SQL Server）连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** - 输入数据库主机名。

   1.  **端口** - 输入数据库端口。

   1.  **实例** - 输入数据库实例。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ec** ret — 选择现有密钥或创建新Secrets Manager密钥来存储你的Amazon RDS（Microsoft SQL Server）身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 'AmazonKendra-Amazon RDS（Microsoft SQL Server）-' 会自动添加到你的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
**注意**  
如果表名中包含特殊字符（非字母数字），则必须使用方括号将表名括起来。例如，*select \$1 from [my-database-table]*
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + **用户 IDs列**-输入包含允许用户访问内容 IDs 的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（“文档” IDs、“**文档****标题**” 和 “**来源**” URLs）中进行选择，以映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到Amazon RDS（微软 SQL Server）**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `sqlserver`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
**注意**  
如果表名中包含特殊字符（非字母数字），则必须使用方括号将表名括起来。例如，*select \$1 from [my-database-table]*
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供密钥的亚马逊资源名称 (ARN)，该Secrets Manager密钥包含您在您的（Amazon RDS微软 SQL Server）账户中创建的身份验证证书。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAM角色** —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Amazon RDS（Microsoft SQL Server）连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Amazon RDS（微软 SQL Server）数据源的IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射**-选择将你的（Amazon RDSMicrosoft SQL Server）数据源字段映射到Amazon Kendra索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Amazon RDS （微软 SQL Server）模板架构](ds-schemas.md#ds-rds-ms-sql-server-schema)。

------

## 注意
<a name="rds-ms-sql-server-notes"></a>
+ Amazon Kendra检查已更新的内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Amazon RDS(MySQL)
<a name="data-source-rds-mysql"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Amazon RDS(MySQL) 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Amazon RDS（Amazon Relational Database Service）是一项网络服务，可以更轻松地在AWS云中设置、操作和扩展关系数据库。如果您是Amazon RDS用户，则可以使用索Amazon Kendra引您的Amazon RDS(MySQL)数据源。Amazon Kendra数据源连接器支持 Amazon RDS MySql 5.6、5.7 和 8.0。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Amazon RDS(MySQL)数据源。

要对Amazon KendraAmazon RDS(MySQL)数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-rds-mysql)
+ [先决条件](#prerequisites-rds-mysql)
+ [连接说明](#data-source-procedure-rds-mysql)
+ [注意](#rds-mysql-notes)

## 支持的功能
<a name="supported-features-rds-mysql"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-rds-mysql"></a>

在使用索Amazon Kendra引Amazon RDS(MySQL)数据源之前，请在Amazon RDS(MySQL)和AWS帐户中进行这些更改。

**在 Amazon RDS(MySQL) 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
最佳做法是提供Amazon Kendra只读数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。你可以在Amazon RDS控制台上找到这些信息。
+ 在 Amazon RDS(MySQL) 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Amazon RDS(MySQL) 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Amazon RDS(MySQL)数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-rds-mysql"></a>

要Amazon Kendra连接到您的Amazon RDS(MySQL)数据源，您必须提供Amazon RDS(MySQL)凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，Amazon RDS(MySQL)请参Amazon Kendra阅[先决条件](#prerequisites-rds-mysql)。

------
#### [ Console ]

**要连接Amazon Kendra到 Amazon RDS(MySQL)** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Amazon RDS(MySQL) 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Amazon RDS(MySQL) 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** – 输入数据库主机 URL，例如：`http://instance URL.region.rds.amazonaws.com`。

   1.  **端口** –输入数据库端口，例如 `5432`。

   1.  **实例** – 输入数据库实例，例如 `postgres`。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的Amazon RDS(MySQL)身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Amazon RDS(MySQL)-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB SQL 查询必须小于 32KB 且不包含任何分号 (;)。 Amazon Kendra将抓取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + **用户 IDs列**-输入包含允许用户访问内容 IDs 的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（**文档 IDs**、**文档标题**和**来源 URLs**）中选择要映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Amazon RDS(MySQL)**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `mySql`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。Amazon RDS(MySQL)密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Amazon RDS(MySQL)连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Amazon RDS(MySQL) S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **字段映射** - 选择将 Amazon RDS(MySQL) 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。

有关要配置的其他重要 JSON 键的列表，请参阅[Amazon RDS (MySQL) 模板架构](ds-schemas.md#ds-rds-mysql-schema)。

------

## 注意
<a name="rds-mysql-notes"></a>
+ 在Amazon Kendra检查更新内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 最佳做法是提供Amazon Kendra只读数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Amazon RDS(Oracle)
<a name="data-source-rds-oracle"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Amazon RDS(Oracle) 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Amazon RDS（Amazon Relational Database Service）是一项网络服务，可以更轻松地在AWS云中设置、操作和扩展关系数据库。如果您是Amazon RDS(Oracle)用户，则可以使用索Amazon Kendra引您的Amazon RDS(Oracle)数据源。Amazon KendraAmazon RDS(Oracle)数据源连接器支持 Amazon RDS Oracle 数据库 21c、甲骨文数据库 19c、甲骨文数据库 12c。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Amazon RDS(Oracle)数据源。

要对Amazon KendraAmazon RDS(Oracle)数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-rds-oracle)
+ [先决条件](#prerequisites-rds-oracle)
+ [连接说明](#data-source-procedure-rds-oracle)
+ [注意](#rds-oracle-notes)

## 支持的功能
<a name="supported-features-rds-oracle"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-rds-oracle"></a>

在使用索Amazon Kendra引Amazon RDS(Oracle)数据源之前，请在Amazon RDS(Oracle)和AWS帐户中进行这些更改。

**在 Amazon RDS(Oracle) 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 在 Amazon RDS(Oracle) 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Amazon RDS(Oracle) 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Amazon RDS(Oracle)数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-rds-oracle"></a>

要Amazon Kendra连接到您的Amazon RDS(Oracle)数据源，您必须提供Amazon RDS(Oracle)凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，Amazon RDS(Oracle)请参Amazon Kendra阅[先决条件](#prerequisites-rds-oracle)。

------
#### [ Console ]

**要连接Amazon Kendra到 Amazon RDS(Oracle)** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Amazon RDS(Oracle) 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Amazon RDS(Oracle) 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** - 输入数据库主机名。

   1.  **端口** - 输入数据库端口。

   1.  **实例** - 输入数据库实例。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的Amazon RDS(Oracle)身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Amazon RDS(Oracle)-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + “用户 ** IDs” 列**-输入包含 IDs 要允许访问内容的用户的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（**文档 IDs**、**文档标题**和**来源 URLs**）中选择要映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Amazon RDS(Oracle)**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `oracle`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。Amazon RDS(Oracle)密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Amazon RDS(Oracle)连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Amazon RDS(Oracle) S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Amazon RDS(Oracle) 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Amazon RDS (甲骨文) 模板架构](ds-schemas.md#ds-rds-oracle-schema)。

------

## 注意
<a name="rds-oracle-notes"></a>
+ 在Amazon Kendra检查更新内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Amazon RDS(PostgreSQL)
<a name="data-source-rds-postgresql"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Amazon RDS(PostgreSQL) 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Amazon RDS是一项 Web 服务，可以更轻松地在AWS云中设置、操作和扩展关系数据库。如果您是Amazon RDS用户，则可以使用索Amazon Kendra引您的Amazon RDS(PostgreSQL)数据源。Amazon KendraAmazon RDS(PostgreSQL)数据源连接器支持 PostgreSQL 9.6。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Amazon RDS(PostgreSQL)数据源。

要对Amazon KendraAmazon RDS(PostgreSQL)数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-rds-postgresql)
+ [先决条件](#prerequisites-rds-postgresql)
+ [连接说明](#data-source-procedure-rds-postgresql)
+ [注意](#rds-postgresql-notes)

## 支持的功能
<a name="supported-features-rds-postgresql"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-rds-postgresql"></a>

在使用索Amazon Kendra引Amazon RDS(PostgreSQL)数据源之前，请在Amazon RDS(PostgreSQL)和AWS帐户中进行这些更改。

**在 Amazon RDS(PostgreSQL) 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。你可以在Amazon RDS控制台上找到这些信息。
+ 在 Amazon RDS(PostgreSQL) 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Amazon RDS(PostgreSQL) 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Amazon RDS(PostgreSQL)数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-rds-postgresql"></a>

要Amazon Kendra连接到您的Amazon RDS(PostgreSQL)数据源，您必须提供Amazon RDS(PostgreSQL)凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，Amazon RDS(PostgreSQL)请参Amazon Kendra阅[先决条件](#prerequisites-rds-postgresql)。

------
#### [ Console ]

**要连接Amazon Kendra到 Amazon RDS(PostgreSQL)** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Amazon RDS(PostgreSQL) 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Amazon RDS(PostgreSQL) 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** – 输入数据库主机 URL，例如：`http://instance URL.region.rds.amazonaws.com`。

   1.  **端口** –输入数据库端口，例如 `5432`。

   1.  **实例** – 输入数据库实例，例如 `postgres`。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的Amazon RDS(PostgreSQL)身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Amazon RDS(PostgreSQL)-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB SQL 查询必须小于 32KB 且不包含任何分号 (;)。 Amazon Kendra将抓取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + “用户 ** IDs” 列**-输入包含 IDs 要允许访问内容的用户的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（“文档” IDs、“**文档****标题**” 和 “**来源**” URLs）中进行选择，以映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Amazon RDS(PostgreSQL)**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `postgresql`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。Amazon RDS(PostgreSQL)密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Amazon RDS(PostgreSQL)连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Amazon RDS(PostgreSQL) S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Amazon RDS(PostgreSQL) 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Amazon RDS (PostgreSQL) 模板架构](ds-schemas.md#ds-rds-postgresql-schema)。

------

## 注意
<a name="rds-postgresql-notes"></a>
+ Amazon Kendra检查已更新的内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Amazon S3
<a name="data-source-s3"></a>

Amazon S3 是一种对象存储服务，可将数据作为对象存储在存储桶中。您可以使用 Amazon Kendra 为 Amazon S3 存储桶中的文档存储库编制索引。

**警告**  
Amazon Kendra 不使用向 Amazon Kendra 委托人授予与 S3 存储桶交互的权限的存储桶策略。相反，它使用 IAM 角色。请确保该成员 Amazon Kendra 未作为可信成员包含在存储桶策略中，以避免在意外向任意委托人授予权限时出现任何数据安全问题。但是，您可以添加存储桶策略，以便在不同的账户中使用 Amazon S3 存储桶。有关更多信息，请参阅[跨账户使用 Amazon S3 的策略](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds-s3-cross-accounts)（在“S3 IAM 角色”选项卡的**数据来源的IAM 角色**下）。有关 S3 数据源的 IAM 角色的信息，请参阅[IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds-s3)。

**注意**  
Amazon Kendra 现在支持升级后的 Amazon S3 连接器。  
已为您自动完成控制台升级。您在控制台中新建的所有连接器都将使用升级后的架构。现在，如果您使用 API，则必须使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象而不是 `S3DataSourceConfiguration` 对象来配置您的连接器。  
使用旧版控制台和 API 架构配置的连接器仍可照常运行，但您将无法编辑或更新它们。如果要编辑或更新连接器配置，必须新建一个连接器。  
我们建议您将连接器工作流程迁移至升级后的版本。使用旧版架构配置的连接器的支持预计将在 2024 年 6 月前终止。

您可以使用[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API 连接到您的 Amazon S3 数据源。

**注意**  
要为您的 Amazon S3 数据源生成同步状态报告，请参阅数据源[疑难解答](https://docs.aws.amazon.com/kendra/latest/dg/troubleshooting-data-sources.html#troubleshooting-data-sources-sync-status-manifest)。

要 Amazon Kendra 对 S3 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-s3)
+ [先决条件](#prerequisites-s3)
+ [连接说明](#data-source-procedure-s3)
+ [创建 Amazon S3 数据源](create-ds-s3.md)
+ [Amazon S3 文档元数据](s3-metadata.md)
+ [Amazon S3 数据源的访问控制](s3-acl.md)
+ [Amazon VPC 与 Amazon S3 数据源一起使用](s3-vpc-example-1.md)

## 支持的功能
<a name="supported-features-s3"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-s3"></a>

在使用 Amazon Kendra 索引 S3 数据源之前，请在您的 S3 和 AWS 账户中进行这些更改。

**在 S3 中，请确保：**
+ 已复制 Amazon S3 存储桶的名称。
**注意**  
您的存储桶必须与您的 Amazon Kendra 索引位于同一区域，并且您的索引必须有权访问包含您的文档的存储桶。
+ 在 S3 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在您的 AWS 账户中，请确保您有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 

如果您没有现有 IAM 角色，则可以在将 S3 数据源连接到时使用控制台创建新 IAM 角色 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色的 ARN 和索引 ID。

## 连接说明
<a name="data-source-procedure-s3"></a>

要连接 Amazon Kendra 到 S3 数据源，您必须提供 S3 数据源的必要详细信息， Amazon Kendra 以便访问您的数据。如果您尚未为 S3 配置 Amazon Kendra，请参阅[先决条件](#prerequisites-s3)。

------
#### [ Console ]

**要连接 Amazon Kendra 到 Amazon S3 ** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **S3 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **S3 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，输入以下可选信息：

   1. **IAM ro** le —选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**数据来源位置**中 - 指定存储您数据的 Amazon S3 存储桶的路径。选择**浏览 S3** 以选择 S3 存储桶。

   1. 对于**最大文件大小** - 指定文件大小上限（以 MB 为单位），仅爬取不超过此大小的文件。允许的最大文件 Amazon Kendra 大小为 50 MB。

   1. 对于（可选）**元数据文件前缀文件夹位置**-指定存储您 fields/attributes 和其他文档元数据的文件夹的路径。选择**浏览 S3** 以找到元数据文件夹。

   1. 对于（可选的）**访问控制列表配置文件的位置** - 指定包含用户及其文档访问权限的 JSON 结构文件的路径。选择**浏览 S3** 以找到 ACL 文件。

   1. （可选）**选择解密密钥** - 选择使用解密密钥。您可以选择使用现有的 AWS KMS 密钥。

   1. 对于（可选的）**其他配置** - 添加正则表达式以包含或排除某些文件。所有路径都是相对于数据来源位置 S3 存储桶的路径。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时， Amazon Kendra 默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，输入以下可选信息：

   1. **默认字段映射**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 选择添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接 Amazon Kendra 到 Amazon S3**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `S3`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **BucketName**— 包含文档的存储桶的名称。
+ **同步模式**-指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。 Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **IAM ro** le —指定`RoleArn`何时调用`CreateDataSource`以向 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及调用 S3 连接器 APIs 所需的公用人员的权限和 Amazon Kendra。有关更多信息，请参阅 [S3 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除筛选条件** - 指定是包含还是排除某些文件名、文件类型、文件路径。您可以使用 glob 模式（一种将通配符模式扩展为与给定模式匹配的路径名称列表的模式）。有关示例，请参阅[《 AWS CLI 命令参考》中的 “排除和包含筛选器的使用](https://docs.aws.amazon.com/cli/latest/reference/s3/#use-of-exclude-and-include-filters)”。
+ **文档元数据和访问控制配置** - 添加包含文档元数据和访问控制信息的文件，例如来源 URI、文档作者、或自定义文档属性/字段，以及用户信息和他们可访问的文档。每个元数据文件都包含有关单个文档的元数据。
+  **字段映射** - 选择将 S3 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [S3 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-s3-schema)。

------

### 了解详情
<a name="s3-learn-more"></a>

要了解有关 Amazon Kendra 与 S3 数据源集成的更多信息，请参阅：
+ [使用支持 VPC Amazon Kendra 的 S3 连接器准确搜索答案](https://aws.amazon.com/blogs/machine-learning/search-for-answers-accurately-using-amazon-kendra-s3-connector-with-vpc-support/)

# 创建 Amazon S3 数据源
<a name="create-ds-s3"></a>

以下示例演示如何创建 Amazon S3 数据源。这些示例假设您已经创建了一个索引和一个有权从索引中读取数据的 IAM 角色。有关该 IAM 角色的更多信息，请参阅[IAM 访问角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。有关创建索引的更多信息，请参阅[创建索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)。

------
#### [ CLI ]

```
aws kendra create-data-source \
 --index-id index ID \
 --name example-data-source \
 --type S3 \
 --configuration '{"S3Configuration":{"BucketName":"bucket name"}}' 
 --role-arn 'arn:aws:iam::account id:role:/role name
```

------
#### [ Python ]

以下 Python 代码片段创建了一个 Amazon S3 数据源。有关完整示例，请参阅[入门 (适用于 Python (Boto3) 的 AWS SDK)](gs-python.md)。

```
print("Create an Amazon S3 data source.")
    
    # Provide a name for the data source
    name = "getting-started-data-source"
    # Provide an optional description for the data source
    description = "Getting started data source."
    # Provide the IAM role ARN required for data sources
    role_arn = "arn:aws:iam::${accountID}:role/${roleName}"
    # Provide the data soource connection information
    s3_bucket_name = "S3-bucket-name"
    type = "S3"
    # Configure the data source
    configuration = {"S3DataSourceConfiguration":
        {
            "BucketName": s3_bucket_name
        }
    }

    data_source_response = kendra.create_data_source(
        Configuration = configuration,
        Name = name,
        Description = description,
        RoleArn = role_arn,
        Type = type,
        IndexId = index_id
    )
```

------

创建数据来源可能需要一些时间。您可以使用 [DescribeDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeDataSource.html)API 监控进度。当数据来源状态为 `ACTIVE` 时，数据来源就已准备就绪。

以下示例演示如何获取数据来源的状态。

------
#### [ CLI ]

```
aws kendra describe-data-source \
 --index-id index ID \
 --id data source ID
```

------
#### [ Python ]

以下 Python 代码片段用于获取有关 S3 数据来源的信息。有关完整示例，请参阅[入门 (适用于 Python (Boto3) 的 AWS SDK)](gs-python.md)。

```
print("Wait for Amazon Kendra to create the data source.")

    while True:
        data_source_description = kendra.describe_data_source(
            Id = "data-source-id",
            IndexId = "index-id"
        )
        status = data_source_description["Status"]
        print(" Creating data source. Status: "+status)
        time.sleep(60)
        if status != "CREATING":
            break
```

------

此数据来源没有计划，因此不会自动运行。要为数据源编制索引，[StartDataSourceSyncJob](https://docs.aws.amazon.com/kendra/latest/APIReference/API_StartDataSourceSyncJob.html)需要调用将索引与数据源同步。

以下示例演示如何同步数据来源。

------
#### [ CLI ]

```
aws kendra start-data-source-sync-job \
 --index-id index ID \
 --id data source ID
```

------
#### [ Python ]

以下 Python 代码片段同步了一个 Amazon S3 数据来源。有关完整示例，请参阅[入门 (适用于 Python (Boto3) 的 AWS SDK)](gs-python.md)。

```
print("Synchronize the data source.")

    sync_response = kendra.start_data_source_sync_job(
        Id = "data-source-id",
        IndexId = "index-id"
    )
```

------

# Amazon S3 文档元数据
<a name="s3-metadata"></a>

您可以使用元数据文件向 Amazon S3 存储桶中的文档添加元数据（有关文档的其他信息）。每个元数据文件都与一个已编入索引的文档相关联。

您的元数据文件必须与已编入索引的文件存储在同一个存储桶中。创建数据源时，您可以使用控制台或`DocumentsMetadataConfiguration`参数`S3Prefix`字段为元 Amazon S3 数据文件指定存储桶中的位置。如果未指定 Amazon S3 前缀，则元数据文件必须与已编入索引的文档存储在相同的位置。

如果您为元数据文件指定 Amazon S3 前缀，则这些文件位于与已编入索引的文档平行的目录结构中。 Amazon Kendra 仅在指定目录中查找您的元数据。如果未读取元数据，请检查目录位置是否与元数据的位置相匹配。

以下示例展示了如何将已编入索引的文档位置映射到元数据文件位置。请注意，文档的 Amazon S3 密钥会附加到元数据的前 Amazon S3 缀后面，然后在后缀后面加上`.metadata.json`以形成元数据文件的路径。 Amazon S3 带有元数据 Amazon S3 前缀和`.metadata.json`后缀的组合 Amazon S3 密钥总长度不得超过 1024 个字符。建议将 Amazon S3 密钥保持在 1000 个字符以下，以便在将密钥与前缀和后缀组合时考虑其他字符。

```
Bucket name:
     s3://bucketName
Document path:
     documents
Metadata path:
     none
File mapping
     s3://bucketName/documents/file.txt -> 
        s3://bucketName/documents/file.txt.metadata.json
```

```
Bucket name:
     s3://bucketName
Document path:
     documents/legal
Metadata path:
     metadata
File mapping
     s3://bucketName/documents/legal/file.txt -> 
        s3://bucketName/metadata/documents/legal/file.txt.metadata.json
```

文档元数据在 JSON 文件中定义。该文件必须是没有 BOM 标记的 UTF-8 文本文件。JSON 文件的文件名必须是 `<document>.<extension>.metadata.json`。在此示例中，“document”是应用元数据的文档的名称，“extension”是该文档的文件扩展名。在 `<document>.<extension>.metadata.json` 中，文档 ID 必须是唯一的。

JSON 文件的内容遵循此模板。所有这些 attributes/fields 都是可选的，因此不必包含所有属性。必须为要包含的每个属性提供一个值；该值不能为空。如果您未指定`_source_uri`，则搜索结果 Amazon Kendra 中返回的链接将指向包含该文档的 Amazon S3 存储桶。 `DocumentId`映射到字段，`s3_document_id`并且是 S3 中文档的绝对路径。

```
{
    "DocumentId": "S3 document ID, the S3 path to doc",
    "Attributes": {
        "_category": "document category",
        "_created_at": "ISO 8601 encoded string",
        "_last_updated_at": "ISO 8601 encoded string",
        "_source_uri": "document URI",
        "_version": "file version",
        "_view_count": number of times document has been viewed,
        "custom attribute key": "custom attribute value",
        additional custom attributes
    },
    "AccessControlList": [
         {
             "Name": "user name",
             "Type": "GROUP | USER",
             "Access": "ALLOW | DENY"
         }
    ],
    "Title": "document title",
    "ContentType": "For example HTML | PDF. For supported content types, see [Types of documents](https://docs.aws.amazon.com/kendra/latest/dg/index-document-types.html)."
}
```

`_created_at` 和 `_last_updated_at` 元数据字段是 ISO 8601 编码的日期。例如，2012-03-25T12:30:10\$101:00 是中部欧洲时间 2012 年 3 月 25 日中午 12:30（10 秒）的 ISO 8601 日期-时间格式。

您可以向 `Attributes` 字段添加有关文档的其他信息，该文档用于筛选查询或对查询响应进行分组。有关更多信息，请参阅 [创建自定义文档字段](custom-attributes.md)。

您可以使用 `AccessControlList` 字段来筛选查询响应。这样，只有特定的用户和组才能访问文档。有关更多信息，请参阅 [根据用户上下文进行筛选](user-context-filter.md)。

# Amazon S3 数据源的访问控制
<a name="s3-acl"></a>

您可以使用配置文件控制对 Amazon S3 数据源中文档的访问权限。您可以在控制台中指定文件，或者在调用[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)或 [UpdateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateDataSource.html)API 时将其指定为`AccessControlListConfiguration`参数。

配置文件包含标识 S3 前缀并列出该前缀的访问设置的 JSON 结构。该前缀可以是路径，也可以是单个文件。如果该前缀是路径，则会将访问设置应用于该路径中的所有文件。JSON 配置文件中存在 S3 前缀数量的最大限制，并且有默认的最大文件大小。有关更多信息，请参阅 [的配额 Amazon Kendra](quotas.md)。

您可以在访问设置中同时指定用户和组。查询索引时，您可以指定用户和组信息。有关更多信息，请参阅 [按属性筛选](user-context-filter.md#context-filter-attribute)。

配置文件的 JSON 结构必须为以下格式：

```
[
    {
        "keyPrefix": "s3://BUCKETNAME/prefix1/",
        "aclEntries": [
            {
                "Name": "user1",
                "Type": "USER",
                "Access": "ALLOW"
            },
            {
                "Name": "group1",
                "Type": "GROUP",
                "Access": "DENY"
            }
        ]
    },
    {
        "keyPrefix": "s3://prefix2",
        "aclEntries": [
            {
                "Name": "user2",
                "Type": "USER",
                "Access": "ALLOW"
            },
            {
                "Name": "user1",
                "Type": "USER",
                "Access": "DENY"
            },
            {
                "Name": "group1",
                "Type": "GROUP",
                "Access": "DENY"
            }
        ]
    }
]
```

# Amazon VPC 与 Amazon S3 数据源一起使用
<a name="s3-vpc-example-1"></a>

本主题提供的 step-by-step示例展示了如何使用亚马逊 S3 连接器通过 Amazon VPC 连接到 Amazon S3 存储桶。此示例假设您开始时使用的是现有的 S3 存储桶。我们建议您上传几个文档到 S3 存储桶来测试示例。

您可以通过 Amazon Kendra 连接到您的 Amazon S3 存储桶 Amazon VPC。为此，您必须在创建 Amazon S3 数据源连接器时指定 Amazon VPC 子网和 Amazon VPC 安全组。

**重要**  
为了让 Amazon Kendra Amazon S3 连接器可以访问您的 Amazon S3 存储桶，请确保您已为虚拟私有云 (VPC) 分配了 Amazon S3 终端节点。

 Amazon Kendra 要通过同步 Amazon S3 存储桶中的文档 Amazon VPC，您必须完成以下步骤：
+ 为设置 Amazon S3 终端节点 Amazon VPC。有关如何设置 Amazon S3 终端节点的更多信息，请参阅*AWS PrivateLink 指南 Amazon S3*中的[网关终端节点](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-s3.html)。
+ （可选）已检查您的 Amazon S3 存储桶策略，确保可以从您分配到的虚拟私有云 (VPC) 访问 Amazon S3 存储桶 Amazon Kendra。有关更多信息，请参阅《*Amazon S3 用户指南*》中的[使用存储桶策略控制从 VPC 端点的访问](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies-vpc-endpoint.html)。

**Topics**
+ [步骤 1：配置 Amazon VPC](#s3-configure-vpc)
+ [（可选）步骤 2：配置 Amazon S3 存储桶策略](#s3-configure-bucket-policy)
+ [步骤 3：创建测试 Amazon S3 数据源连接器](#s3-connect-vpc)

## 步骤 1：配置 Amazon VPC
<a name="s3-configure-vpc"></a>

创建一个 VPC 网络，包括一个带有网 Amazon S3 关终端节点和安全组的私有子网 Amazon Kendra ，供以后使用。

**为 VPC 配置私有子网、S3 端点和安全组**

1. 登录 AWS 管理控制台 并打开 Amazon VPC 控制台，网址为[https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。

1. **创建具有私有子网和 S3 终端节点的 VPC Amazon Kendra 以供使用：**

   在导航窗格中，选择**您的 VPCs**，然后选择**创建 VPC**。

   1. 对于**要创建的资源**，选择 **VPC 等**。

   1. 对于**名称标签**，启用**自动生成**，然后输入 **kendra-s3-example**。

   1. 对于 **IPv4 / IPv6 CIDR 块**，请保留默认值。

   1. 对于**可用区数量 (AZs)**，请选择**数字 1**。

   1. 选择 “**自定义**” AZs，然后从 “**第一个可用区” 列表中选择一个可用区**。

      Amazon Kendra 仅支持一组特定的可用区。

   1. 对于**公有子网数量**，选择 **0**。

   1. 对于**私有子网数量**，选择 **1**。

   1. 对于 **NAT 网关**，选择 **无**。

   1. 对于 **VPC 端点**，请选择**Amazon S3 网关**。

   1. 将其他值保留为默认值。

   1. 选择**创建 VPC**。

      等待**创建 VPC** 工作流程完成。然后，选择**查看 VPC** 以检查您刚刚创建的 **VPC**。

   现在，您已经创建了一个带有私有子网的 VPC 网络，该子网无法访问公共互联网。

1. **复制您的 Amazon S3 端点的 VPC 端点 ID：**

   1. 在导航窗格中，选择**端点**。

   1. 在**端点**列表中，找到您刚刚与您的 VPC 一起创建的 Amazon S3 端点 `kendra-s3-example-vpce-s3`。

   1. 记下 **VPC 端点 ID**。

   现在，您已经创建了一个 Amazon S3 网关端点来通过子网访问您的 Amazon S3 存储桶。

1. **创建供 Amazon Kendra 使用的**安全组**：**

   1. 从导航窗格中，选择**安全组**，然后选择**创建安全组**。

   1. 对于**安全组名称**，输入 **s3-data-source-security-group**。

   1. 从 **Amazon VPC** 列表中选择您的 VPC。

   1. 将**入站规则**和**出站规则**保留为默认值。

   1. 选择**创建安全组**。

   现在您已创建了 VPC 安全组。

在连接器配置过程中，您将创建的子网和安全组分配给 Amazon Kendra Amazon S3 数据源连接器。

## （可选）步骤 2：配置 Amazon S3 存储桶策略
<a name="s3-configure-bucket-policy"></a>

在此可选步骤中，您将学习如何配置 Amazon S3 存储桶策略，以使您的 Amazon S3 存储桶仅能从您分配给 Amazon Kendra的 VPC 访问。

Amazon Kendra 使用 IAM 角色访问您的 Amazon S3 存储桶，并且不需要您配置 Amazon S3 存储桶策略。但是，如果您想使用 Amazon S3 存储桶配置 Amazon S3 连接器，而该存储桶具有限制从公共 Internet 访问的现有策略，那么创建存储桶策略可能会很有用。

**配置您的 Amazon S3 存储桶策略**

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 在导航窗格中选择**存储桶**。

1. 选择您要与之同步的 Amazon S3 存储桶的名称 Amazon Kendra。

1. 选择**权限**选项卡，向下滚动到**存储桶策略**，然后单击**编辑**。

1. 添加或修改您的存储桶策略，使其仅允许从您创建的 VPC 端点进行访问。

   下面是一个示例存储桶策略。将 *`bucket-name`* 和 *`vpce-id`* 替换为您的 Amazon S3 存储桶名称和您之前记下的 Amazon S3 端点 ID。

1. 选择**保存更改**。

现在，只能从您创建的特定 VPC 访问您的 S3 存储桶。

## 步骤 3：创建测试 Amazon S3 数据源连接器
<a name="s3-connect-vpc"></a>

要测试您的 Amazon VPC 配置，请创建一个 Amazon S3 连接器。然后，按照 [Amazon S3](https://docs.aws.amazon.com/kendra/latest/dg/data-source-s3.html) 中概述的步骤，将其配置为使用您创建的 VPC。

对于 Amazon VPC 配置值，请选择您在本示例中创建的值：
+ **Amazon VPC（VPC）**– `kendra-s3-example-vpc`
+ **子网** – `kendra-s3-example-subnet-private1-[availability zone]`
+ **安全组** – `s3-data-source-security-group`

等待连接器创建完成。创建 Amazon S3 连接器后，选择 “**立即同步**” 以启动同步。

完成同步可能需要几分钟到几小时，具体取决于您的 Amazon S3 存储桶中有多少文档。为了测试该示例，我们建议您只上传少量文档到 S3 存储桶。如果您的配置正确，最终应该会看到**同步状态**为**已完成**。

如果遇到任何错误，请参阅[Amazon VPC 连接疑难解答](https://docs.aws.amazon.com/kendra/latest/dg/vpc-connector-troubleshoot.html)。

# Amazon Kendra 网络爬虫
<a name="data-source-web-crawler"></a>

您可以使用 Amazon Kendra Web Crawler 来抓取和索引网页。

您只能爬取公共网站和使用安全通信协议（安全超文本传输协议（HTTPS））的公司内部网站。如果您在爬取网站时收到错误，则可能是该网站被阻止爬网。要爬取内部网站，可以设置 Web 代理。Web 代理必须面向公众。您还可以使用身份验证来访问和爬取网站。

*当选择要编制索引的网站时，您必须遵守 [Amazon 可接受使用政策](https://aws.amazon.com/aup/)以及所有其他 Amazon 条款。请记住，您只能使用 Amazon Kendra Web Crawler 来索引自己的网页或您有权编制索引的网页。要了解如何阻止 Amazon Kendra Web Crawler 将您的网站编入索引，请参阅[为 Amazon Kendra Web Crawler 配置`robots.txt`文件](stop-web-crawler.md)。*

**注意**  
滥用 Amazon Kendra Web Crawler 来积极抓取你不拥有的网站或网页是不被视为**不可**接受的用法。

Amazon Kendra 有两个版本的web crawler连接器。每个版本支持的功能包括：

**Amazon Kendra Web Crawler 连接器 v1.0/API [https://docs.aws.amazon.com/kendra/latest/dg/API_WebCrawlerConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_WebCrawlerConfiguration.html)**
+ 网络代理
+ 包含/排除筛选条件

**Amazon Kendra Web Crawler 连接器 v2.0/API [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)**
+ 字段映射
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 网络代理
+ 网站的基本身份验证、NTLM/Kerberos 身份验证、SAML 身份验证和表单身份验证
+ 虚拟私有云（VPC）

**重要**  
不支持 Web Crawler v2.0 连接器的创建。 CloudFormation如果需要 CloudFormation 支持，请使用 Web Crawler v1.0 连接器。

要对 Amazon Kendra 网络爬虫数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [Amazon Kendra 网络爬虫连接器 v1.0](data-source-v1-web-crawler.md)
+ [Amazon Kendra 网络爬虫连接器 v2.0](data-source-v2-web-crawler.md)
+ [为 Amazon Kendra Web Crawler 配置`robots.txt`文件](stop-web-crawler.md)

# Amazon Kendra 网络爬虫连接器 v1.0
<a name="data-source-v1-web-crawler"></a>

您可以使用 Amazon Kendra Web Crawler 来抓取和索引网页。

您只能爬取公共网站和使用安全通信协议（安全超文本传输协议（HTTPS））的网站。如果您在爬取网站时收到错误，则可能是该网站被阻止爬网。要爬取内部网站，可以设置 Web 代理。Web 代理必须面向公众。

*当选择要编制索引的网站时，您必须遵守 [Amazon 可接受使用政策](https://aws.amazon.com/aup/)以及所有其他 Amazon 条款。请记住，您只能使用 Amazon Kendra Web Crawler 来索引自己的网页或您有权编制索引的网页。要了解如何阻止 Amazon Kendra Web Crawler 将您的网站编入索引，请参阅[为 Amazon Kendra Web Crawler 配置`robots.txt`文件](stop-web-crawler.md)。*

**注意**  
滥用 Amazon Kendra Web Crawler 来积极抓取你不拥有的网站或网页是不被视为**不可**接受的用法。

要对 Amazon Kendra 网络爬虫数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v1-web-crawler)
+ [先决条件](#prerequisites-v1-web-crawler)
+ [连接说明](#data-source-v1-procedure-web-crawler)
+ [了解详情](#web-crawler-learn-more)

## 支持的功能
<a name="supported-features-v1-web-crawler"></a>
+ Web 代理
+ 包含/排除筛选条件

## 先决条件
<a name="prerequisites-v1-web-crawler"></a>

在使用 Amazon Kendra 索引您的网站之前，请先检查您的网站和 AWS 帐户的详细信息。

**对于您的网站，请确保：**
+ 已复制您要编入索引 URLs 的网站的种子或站点地图。
+ **对于需要基本身份验证的网站**：记下用户名和密码，并复制网站的主机名和端口号。
+ **可选：**如果您想使用 Web 代理连接到要爬取的内部网站，请复制网站的主机名和端口号。该 Web 代理必须面向公众。 Amazon Kendra 支持连接到通过基本身份验证提供支持的 Web 代理服务器，或者无需身份验证即可连接的服务器。
+ 在网页以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在您的 AWS 账户中，请确保您有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 对于需要身份验证的网站，或者如果使用带身份验证的 Web 代理，请将您的身份验证凭据存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将web crawler数据源连接到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-v1-procedure-web-crawler"></a>

要 Amazon Kendra 连接到您的web crawler数据源，您必须提供web crawler数据源的必要详细信息， Amazon Kendra 以便访问您的数据。如果您尚未进行配置，web crawler请参 Amazon Kendra 阅[先决条件](#prerequisites-v1-web-crawler)。

------
#### [ Console ]

**要连接 Amazon Kendra 到 web crawler** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Web 爬网程序连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Web 爬网程序连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **对于**来源**，根据您的用例在**来源 URLs和来源站点地图**之间进行选择，然后输入每个站点地图的值。**

      您最多可以添加 10 个来源地图 URLs 和 3 个站点地图。
**注意**  
如果您想抓取站点地图，请检查基本网址或根网址是否与站点地图页面上 URLs 列出的网址相同。例如，如果您的站点地图 URL 是 *https://example.com/sitemap-page.html*，则此站点地图页面上 URLs 列出的也应使用基本 URL “https://example.com/”。

   1. （可选）对于 **Web 代理** - 请输入以下信息：

      1. **主机名** - 需要 Web 代理的主机名。

      1. **端口号** - 主机 URL 传输协议使用的端口。端口号应为介于 0 到 65535 之间的数值。

      1. 对于 **Web 代理凭证** - 如果您的 Web 代理连接需要身份验证，请选择现有密钥或创建新密钥来存储您的身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀“AmazonKendra-WebCrawler-”会自动添加到您的密钥名称中。

         1. 对于**用户名**和**密码** - 输入网站的这些基本身份验证凭证。

         1. 选择**保存**。

   1. （可选）**需要身份验证的主机** - 选择添加其他需要身份验证的主机。

   1. **IAM 角色**-选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **爬取范围** - 选择要爬取的网页类型。

   1. **抓取深度**-从种子 URL 中选择 Amazon Kendra 应该爬行的关卡数。

   1. **高级爬取设置**和**其他配置**，输入以下信息：

      1. **最大文件大小** - 要爬取的最大网页或附件大小。最小 0.000001 MB（1 字节）。最大 50 MB。

      1. **每页最多链接数** - 在每个页面上爬取的最大链接数量。按显示顺序爬取链接。最低限度 1 link/page. Maximum 1000 links/page。

      1. **最大限制**-每分钟每个主机名的最大 URLs 搜索次数。最低限度 1 URLs/host name/minute. Maximum 300 URLs/host name/minute。

      1. 正@@ **则表达式模式**-添加正则表达式模式以包含或排除某些模式。 URLs最多可以添加 100 个模式。

   1. 在 “**同步运行计划**” 中，“**频率**”-选择与数据源同步的频率。 Amazon Kendra 

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接 Amazon Kendra 到 web crawler**

您必须使用 [WebCrawlerConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_WebCrawlerConfiguration.html)API 指定以下内容：
+ **URLs**—指定网站的种子或起点 URLs ，或者您要使用和进行[https://docs.aws.amazon.com/kendra/latest/dg/API_SeedUrlConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_SeedUrlConfiguration.html)爬网 URLs 的网站的站点地图。[https://docs.aws.amazon.com/kendra/latest/dg/API_SiteMapsConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_SiteMapsConfiguration.html)
**注意**  
如果您想抓取站点地图，请检查基本网址或根网址是否与站点地图页面上 URLs 列出的网址相同。例如，如果您的站点地图 URL 是 *https://example.com/sitemap-page.html*，则此站点地图页面上 URLs 列出的也应使用基本 URL “https://example.com/”。
+ **密钥 Amazon资源名称（ARN）**- 如果网站需要基本身份验证，则需要提供主机名、端口号和用于存储您的用户名和密码的基本身份验证凭证的密钥。您可以使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_AuthenticationConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_AuthenticationConfiguration.html) API 提供密钥 ARN。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "username": "user name",
      "password": "password"
  }
  ```

  您也可以使用 AWS Secrets Manager 密钥提供 Web 代理凭证。您可以使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_ProxyConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_ProxyConfiguration.html) API 提供网站主机名称和端口号，还可以选择提供存储您的 Web 代理凭证的密钥。
+ **IAM ro** le —指定`RoleArn`何时调用`CreateDataSource`为 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及呼叫 Web 爬网程序连接器 APIs 所需的公众的权限，以及。 Amazon Kendra有关更多信息，请参阅 [Web 爬网程序数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **爬取模式** - 选择是仅爬取网站主机名，还是爬取带有子域的主机名，还是同时爬取网页链接到的其他域名。
+ 从种子层爬取的“深度”或层数。例如，种子 URL 页面的深度为 1，在该页面上同时爬取的所有超链接的深度都是 2。
+ 单个网页 URLs 上要抓取的最大数量。
+ 要爬取的网页的最大大小（以 MB 为单位）。
+ 每位网站主机每分钟的最大 URLs 抓取次数。
+ 用于连接和爬取内部网站的 Web 代理主机和端口号。例如，*https://a.example.com/page1.html* 的主机名是“a.example.com”，端口号是 443，这是 HTTPS 的标准端口。如果连接至网站主机需要 Web 代理凭证，您可以创建存储凭证的 AWS Secrets Manager 。
+ 访问和爬取需要用户身份验证的网站的身份验证信息。
+ 您可以使用*自定义文档富集*工具将 HTML 元标签提取为字段。有关更多信息，请参阅[在提取过程中自定义文档元数据](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html)。有关提取 HTML 元标签的示例，请参阅 [CDE 示例](https://github.com/aws-samples/amazon-kendra-cde-examples)。
+  “**包含” 和 “排除” 筛选器**-指定是包含还是排除某些 URLs筛选器。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。

------

## 了解详情
<a name="web-crawler-learn-more"></a>

要了解有关 Amazon Kendra 与web crawler数据源集成的更多信息，请参阅：
+ [使用 Amazon Kendra Web Crawler 重新构想知识发现](https://aws.amazon.com/blogs/machine-learning/reimagine-knowledge-discovery-using-amazon-kendras-web-crawler/)

# Amazon Kendra 网络爬虫连接器 v2.0
<a name="data-source-v2-web-crawler"></a>

您可以使用 Amazon Kendra Web Crawler 来抓取和索引网页。

您只能爬取公共网站和使用安全通信协议（安全超文本传输协议（HTTPS））的公司内部网站。如果您在爬取网站时收到错误，则可能是该网站被阻止爬网。要爬取内部网站，可以设置 Web 代理。Web 代理必须面向公众。您还可以使用身份验证来访问和爬取网站。

Amazon Kendra Web Crawler v2.0 使用 Selenium 网络爬虫软件包和 Chromium 驱动程序。 Amazon Kendra 使用持续集成 (CI) 自动更新 Selenium 和 Chromium 驱动程序的版本。

*当选择要编制索引的网站时，您必须遵守 [Amazon 可接受使用政策](https://aws.amazon.com/aup/)以及所有其他 Amazon 条款。请记住，您只能使用 Amazon Kendra Web Crawler 来索引自己的网页或您有权编制索引的网页。要了解如何阻止 Amazon Kendra Web Crawler 将您的网站编入索引，请参阅[为 Amazon Kendra Web Crawler 配置`robots.txt`文件](stop-web-crawler.md)。* 。滥用 Amazon Kendra Web Crawler 来积极抓取你不拥有的网站或网页是不被视为**不可**接受的用法。

要对 Amazon Kendra 网络爬虫数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**注意**  
Web Crawler 连接器 v2.0 *不*支持从 AWS KMS 加密存储桶中抓取网站列表。 Amazon S3 它仅支持使用 Amazon S3 托管密钥进行服务器端加密。

**重要**  
不支持 Web Crawler v2.0 连接器的创建。 CloudFormation如果需要 CloudFormation 支持，请使用 Web Crawler v1.0 连接器。

**Topics**
+ [支持的功能](#supported-features-v2-web-crawler)
+ [先决条件](#prerequisites-v2-web-crawler)
+ [连接说明](#data-source-v2-procedure-web-crawler)

## 支持的功能
<a name="supported-features-v2-web-crawler"></a>
+ 字段映射
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 网络代理
+ 网站的基本身份验证、NTLM/Kerberos 身份验证、SAML 身份验证和表单身份验证
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v2-web-crawler"></a>

在使用 Amazon Kendra 索引您的网站之前，请先检查您的网站和 AWS 帐户的详细信息。

**对于您的网站，请确保：**
+ 已复制您要编入索引 URLs 的网站的种子或站点地图。您可以将存储 URLs 在文本文件中，然后将其上传到 Amazon S3 存储桶。文本文件中的每个 URL 都必须对单行进行格式化。如果您想将站点地图存储在 Amazon S3 存储桶中，请确保已复制站点地图 XML 并将其保存在 XML 文件中。您也可以将多个站点地图 XML 文件压缩成一个 ZIP 文件。
**注意**  
（本地/服务器） Amazon Kendra 会检查中 AWS Secrets Manager 包含的端点信息是否与数据源配置详细信息中指定的端点信息相同。这有助于防止出现[混淆代理人问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)，这是一个安全问题，即用户无权执行操作，但可以将 Amazon Kendra 作为代理来访问配置的密钥和执行操作。如果以后更改端点信息，则必须创建一个新密钥来同步此信息。
+ **对于需要基本、NTLM 或 Kerberos 身份验证的网站**：
  + 已记下您的网站身份验证凭证，其中包括用户名和密码。
**注意**  
Amazon Kendra Web Crawler v2.0 支持包括密码哈希的 NTLM 身份验证协议和包括密码加密的 Kerberos 身份验证协议。
+ **对于需要 SAML 或登录表单身份验证的网站**：
  + 已记下您的网站身份验证凭证，其中包括用户名和密码。
  + 复制了用户名字段 XPaths （如果使用 SAML 则还包括用户名按钮）、密码字段和按钮的（XML 路径语言），并复制了登录页面 URL。你可以使用 Web 浏览器的开发者工具来找到 of 元素。 XPaths XPaths 通常遵循这种格式:`//tagname[@Attribute='Value']`.
**注意**  
Amazon Kendra Web Crawler v2.0 使用无头 Chrome 浏览器和表单中的信息，通过 OAuth 2.0 保护的 URL 进行身份验证和授权访问。
+ **可选**：如果您想使用 Web 代理连接到要爬取的内部网站，请复制 Web 代理服务器的主机名和端口号。Web 代理必须面向公众。 Amazon Kendra 支持连接到由基本身份验证支持的 Web 代理服务器，或者无需身份验证即可连接。
+ **可选**：如果您想使用 VPC 连接到要爬取的内部网站，请复制虚拟私有云（VPC）子网 ID。有关更多信息，请参阅[配置 Amazon VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。
+ 在网页以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在您的 AWS 账户中，请确保您有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该 IAM 角色的 Amazon 资源名称。
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 对于需要身份验证的网站，或者如果使用带身份验证的 Web 代理，请将您的身份验证凭据存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将web crawler数据源连接到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-v2-procedure-web-crawler"></a>

要 Amazon Kendra 连接到您的web crawler数据源，您必须提供web crawler数据源的必要详细信息， Amazon Kendra 以便访问您的数据。如果您尚未进行配置，web crawler请参 Amazon Kendra 阅[先决条件](#prerequisites-v2-web-crawler)。

------
#### [ Console ]

**要连接 Amazon Kendra 到 web crawler** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Web 爬网程序连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Web 爬网程序连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **来源** **-选择**来源 URLs、源****站点地图、源文件和源站点地图 URLs****文件**。**如果您选择使用包含最多 100 个种子列表的文本文件 URLs，则需要指定 Amazon S3 存储文件的存储桶的路径。如果您选择使用站点地图 XML 文件，则需要指定存储文件的 Amazon S3 存储桶的路径。您也可以将多个站点地图 XML 文件压缩成一个 ZIP 文件。否则，您可以手动输入最多 10 个种子或起点 URLs，以及最多三个站点地图 URLs。
**注意**  
如果您想抓取站点地图，请检查基本网址或根网址是否与站点地图页面上 URLs 列出的网址相同。例如，如果您的站点地图 URL 是 *https://example.com/sitemap-page.html*，则此站点地图页面上 URLs 列出的也应使用基本 URL “https://example.com/”。

      如果您的网站需要身份验证才能访问，则可以选择基本身份验证、NTLM/Kerberos、SAML 或表单身份验证。否则，请选择不进行身份验证的选项。
**注意**  
如果您想稍后编辑数据源以通过站点地图身份 URLs 验证来更改种子，则必须创建一个新的数据源。 Amazon Kendra 使用 Secrets Manager 密钥中的种子 URLs 端点信息配置数据源进行身份验证，因此在更改为站点地图时无法重新配置数据源。

      1. AWS Secrets Manager s@@ **ecret** —如果您的网站需要相同的身份验证才能访问网站，请选择现有密钥或创建新 Secrets Manager 密钥来存储您的网站凭据。如果您选择创建新密钥，则会打开一个 AWS Secrets Manager 秘密窗口。

        如果您选择**基本**或 **NTML/Kerberos** 身份验证，请输入密钥的名称以及用户名和密码。NTLM 身份验证协议包括密码哈希，Kerberos 身份验证协议包括密码加密。

        如果您选择 **SAML** 或**表单**身份验证，请输入密钥的名称以及用户名和密码。 XPath 用于用户名字段（如果使用 SAML，则 XPath 用于用户名按钮）。 XPaths 用于密码字段和按钮以及登录页面 URL。你可以使用 Web 浏览器的开发者工具找到元素的 XPaths （XML 路径语言）。 XPaths 通常遵循这种格式:`//tagname[@Attribute='Value']`.

   1. （可选）**Web 代理** - 输入要用于连接内部网站的代理服务器的主机名和端口号。例如，*https://a.example.com/page1.html* 的主机名是“a.example.com”，端口号是 443，这是 HTTPS 的标准端口。如果需要网络代理凭据才能连接到网站主机，则可以创建 AWS Secrets Manager 用于存储凭据的。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAM 角色**-选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **同步范围**-设置抓取网页的限制，包括其域名、文件大小和链接；并 URLs 使用正则表达式模式进行筛选。

      1. （可选）**爬取域名范围** - 选择是仅爬取网站域名、包含子域名的域名，还是同时爬取网页链接到的其他域名。默认情况下， Amazon Kendra 仅抓取您要抓取的网站的域名。

      1. （可选）**其他配置** - 设置以下设置：
         + **爬取深度** -“深度”或从种子层开始的爬取层数。例如，种子 URL 页面的深度为 1，在该页面上同时爬取的所有超链接的深度都是 2。
         + **最大文件大小** - 要爬取的网页或附件的最大大小（以 MB 为单位）。
         + **每页的最大链接**数-单个网页 URLs上可供抓取的最大链接数。
         + **抓取速度的最大限制**-每位网站主机每分钟的最大 URLs抓取次数。
         + **文件** - 选择爬取网页链接到的文件。
         + **Crawl and index URLs**-添加正则表达式模式以包含或排除抓取某些内容 URLs，以及将这些 URL 网页上的任何超链接编入索引。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时， Amazon Kendra 默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. **同步运行计划** - 对于**频率**，选择 Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从 Amazon Kendra 生成的网页和文件默认字段中选择要映射到索引的网页。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接 Amazon Kendra 到 web crawler**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-web-crawler-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `WEBCRAWLERV2`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **URLs**—指定要抓取 URLs 的网站的种子或起点或网站地图 URLs 。您可以指定存储种子列表的 Amazon S3 存储桶的路径 URLs。种子文本文件中的每个 URL 都 URLs 必须使用单独的行进行格式化。您还可以指定存储站点地图 XML 文件的 Amazon S3 存储桶的路径。您可以将多个站点地图文件压缩成一个 ZIP 文件，然后将 ZIP 文件存储在 Amazon S3 存储桶中。
**注意**  
如果您想抓取站点地图，请检查基本网址或根网址是否与站点地图页面上 URLs 列出的网址相同。例如，如果您的站点地图 URL 是 *https://example.com/sitemap-page.html*，则此站点地图页面上 URLs 列出的也应使用基本 URL “https://example.com/”。
+ **同步模式**-指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。 Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **身份验证** - 如果您的网站需要相同的身份验证，请指定 `BasicAuth`、`NTLM_Kerberos`、`SAML` 或 `Form` 身份验证。如果您的网站不需要身份验证，请指定`NoAuthentication`。
+ **密钥 Amazon 资源名称（ARN）**- 如果您的网站需要基本、NTLM 或 Kerberos 身份验证，则需要提供存储您的用户名和密码的身份验证凭证的密钥。您要提供 AWS Secrets Manager 密钥的 Amazon 资源名称（ARN）。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "seedUrlsHash": "Hash representation of all seed URLs",
      "userName": "user name",
      "password": "password"
  }
  ```

  如果您的网站需要 SAML 身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "seedUrlsHash": "Hash representation of all seed URLs",                                
      "userName": "user name",
      "password": "password",
      "userNameFieldXpath": "XPath for user name field",
      "userNameButtonXpath": "XPath for user name button",
      "passwordFieldXpath": "XPath for password field",
      "passwordButtonXpath": "XPath for password button",
      "loginPageUrl": "Full URL for website login page"
  }
  ```

  如果您的网站需要表单身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "seedUrlsHash": "Hash representation of all seed URLs",
      "userName": "user name",
      "password": "password",
      "userNameFieldXpath": "XPath for user name field",
      "passwordFieldXpath": "XPath for password field",
      "passwordButtonXpath": "XPath for password button",
      "loginPageUrl": "Full URL for website login page"
  }
  ```

  你可以使用 Web 浏览器的开发者工具找到元素的 XPaths （XML 路径语言）。 XPaths 通常遵循这种格式:`//tagname[@Attribute='Value']`.

  您也可以使用 AWS Secrets Manager 密钥提供 Web 代理凭证。
+ **IAM ro** le —指定`RoleArn`何时调用`CreateDataSource`为 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及呼叫 Web 爬网程序连接器 APIs 所需的公众的权限，以及。 Amazon Kendra有关更多信息，请参阅 [Web 爬网程序数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **域范围** - 选择是仅爬取带有子域名的网站域名，还是同时爬取网页链接到的其他域名。默认情况下， Amazon Kendra 仅抓取您要抓取的网站的域名。
+ 从种子层爬取的“深度”或层数。例如，种子 URL 页面的深度为 1，在该页面上同时爬取的所有超链接的深度都是 2。
+ 单个网页 URLs 上要抓取的最大数量。
+ 要爬取的网页或附件的最大大小（以 MB 为单位）。
+ 每位网站主机每分钟的最大 URLs 抓取次数。
+ 用于连接和爬取内部网站的 Web 代理主机和端口号。例如，*https://a.example.com/page1.html* 的主机名是“a.example.com”，端口号是 443，这是 HTTPS 的标准端口。如果连接至网站主机需要 Web 代理凭证，您可以创建存储凭证的 AWS Secrets Manager 。
+ **包含和排除过滤器**-指定是包括还是排除抓取这些 URL 网页上的某些超链接 URLs 和索引任何超链接。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **字段映射**-选择将网页和网页文件的字段映射到您的 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。

有关要配置的其他重要 JSON 键的列表，请参阅 [Amazon Kendra Web 爬网程序模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-schema-web-crawler)。

------

# 为 Amazon Kendra Web Crawler 配置`robots.txt`文件
<a name="stop-web-crawler"></a>

Amazon Kendra 是一种智能搜索服务， AWS 客户使用它来索引和搜索自己选择的文档。为了索引网络上的文档，客户可以使用 Amazon Kendra Web Crawler，指明应为哪些 URL 编制索引以及其他操作参数。 Amazon Kendra 在为任何特定网站编制索引之前，客户必须获得授权。

Amazon Kendra Web Crawler 尊重标准 robots.txt 指令，例如`Allow`和。`Disallow`您可以修改网站`robots.txt`文件以控制 Amazon Kendra Web Crawler 如何抓取您的网站。

## 配置 Amazon Kendra Web Crawler 如何访问您的网站
<a name="configure-web-crawler-website-access"></a>

您可以使用`Allow`和指`Disallow`令控制 Amazon Kendra Web Crawler 如何为您的网站编制索引。您还可以控制为哪些网页编制索引，以及不爬取哪些网页。

**要允许 Amazon Kendra Web Crawler 抓取除不允许的网页之外的所有网页，请使用以下指令：**

```
User-agent: amazon-kendra    # Amazon Kendra Web Crawler
Disallow: /credential-pages/ # disallow access to specific pages
```

**要允许 Amazon Kendra Web Crawler 仅抓取特定的网页，请使用以下指令：**

```
User-agent: amazon-kendra    # Amazon Kendra Web Crawler
Allow: /pages/ # allow access to specific pages
```

**要允许 Amazon Kendra Web Crawler 抓取所有网站内容并禁止任何其他机器人抓取，请使用以下指令：**

```
User-agent: amazon-kendra # Amazon Kendra Web Crawler
Allow: / # allow access to all pages
User-agent: * # any (other) robot
Disallow: / # disallow access to any pages
```

## 阻止 Amazon Kendra Web Crawler 抓取您的网站
<a name="stop-web-crawler-access"></a>

您可以使用该`Disallow`指令阻止 Amazon Kendra Web Crawler 将您的网站编入索引。您还可以控制爬取哪些网页以及不爬取哪些网页。

**要阻止 Amazon Kendra Web Crawler 抓取网站，请使用以下指令：**

```
User-agent: amazon-kendra # Amazon Kendra Web Crawler
Disallow: / # disallow access to any pages
```

如果您对 Amazon Kendra Web Crawler 有任何疑问或疑虑，可以联系[AWS 支持团队](https://aws.amazon.com/contact-us/?nc1=f_m)。

# Box
<a name="data-source-box"></a>

Box 是提供文件托管功能的云存储服务。您可以使用Amazon Kendra索引 Box 内容中的内容，包括评论、任务和网络链接。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [BoxConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BoxConfiguration.html)API 连接Amazon Kendra到 Box 数据源。

要对 Amazon Kendra Box 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-box)
+ [先决条件](#prerequisites-box)
+ [连接说明](#data-source-procedure-box)
+ [了解详情](#box-learn-more)
+ [注意](#box-notes)

## 支持的功能
<a name="supported-features-box"></a>

Amazon KendraBox 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 更改日志、完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-box"></a>

在使用Amazon Kendra索引 Box 数据源之前，请在您的 Box 和AWS账户中进行这些更改。

**在 Box 中，请确保：**
+ 一个 Box Enterprise 或 Box Enterprise Plus 账户
+ 在 Box 开发人员控制台中创建了一个 Box 自定义应用程序，并将其配置为使用 JSON Web Tokens（JWT）进行服务器端身份验证。有关更多详细信息，请参阅[有关创建自定义应用程序的 Box 文档](https://developer.box.com/guides/applications/app-types/platform-apps/)和 [配置 JWT 身份验证的 Box 文档](https://developer.box.com/guides/authentication/jwt/)。
+ 将您的**应用程序访问权限级别**设置为 **应用程序 \$1 企业版访问程序**，并允许它**使用 as-user 标头进行 API 调用**。
+ 使用管理员用户在您的 Box 应用程序中添加以下**应用程序范围**：
  + 写入存储在 Box 中的所有文件和文件夹
  + 管理用户
  + 管理组
  + 管理企业版属性
+ 已配置的密 Public/Private 钥对，包括客户端 ID、客户机密、公钥 ID、私钥 ID、密码短语和企业 ID，用作您的身份验证凭证。有关更多详细信息，请参阅 [Public and private key pair](https://developer.box.com/guides/authentication/jwt/jwt-setup/#public-and-private-key-pair)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 已从 Box 开发者控制台设置或 Box 应用程序中复制您的 Box 企业 ID。例如 *801234567*。
+ 在 Box 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Box 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Box 数据源连接至时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-box"></a>

要连接Amazon Kendra到 Box 数据源，您必须提供 Box 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Box 配置Amazon Kendra，请参阅[先决条件](#prerequisites-box)。

------
#### [ Console ]

**连接Amazon Kendra到 Box** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Box 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Box 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Box 企业版 ID** - 输入您的 Box 企业版 ID。例如 *801234567*。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 Box 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Box-” 会自动添加到您的密钥名称中。

      1. 对于 “**客户端 ID**”、“**客户机密**”、“**公钥 ID****”、“私钥 ID**” 和 “**密码短语**”，请输入您在框中配置的 Public/Private 密钥中的值。

      1. 添加并保存您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **Box 文件** – 选择是否爬取 Web 链接、评论和任务。

   1. 对于**其他配置** - 添加正则表达式模式以包含或排除某些内容。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 修改过的新同步：每次数据源与索引同步时，仅为新增和修改过的内容编制索引。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
      + 新增、修改、删除的同步：每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。

   1. 在**同步运行计划**的**频率**中 - 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接Amazon Kendra到 Box**

您必须使用 [BoxConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BoxConfiguration.html)API 指定以下内容：

**Box 企业版 ID** - 输入您的 Box 企业版 ID。您可以在 Box 开发人员控制台设置中或在 Box 中配置应用程序时找到企业 ID。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Box 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "clientID": "client-id",
      "clientSecret": "client-secret",
      "publicKeyID": "public-key-id",
      "privateKey": "private-key",
      "passphrase": "pass-phrase"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及呼叫 Box 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Box 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **虚拟私有云（VPC）**- 在数据来源配置中指定 `VpcConfiguration`。请参阅[配置 Amazon Kendra 以使用 VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。
+  **更改日志** - Amazon Kendra 是否应使用 Box 数据来源更改日志机制来确定是否必须在索引中添加文档。
**注意**  
如果您不想让 Amazon Kendra 扫描所有文档，请使用更改日志。如果您的更改日志很大，则扫描 Box 数据源中的文档所花费的时间可能比处理更改日志所需的时间Amazon Kendra少。如果您是首次将 Box 数据来源与索引同步，则会扫描所有文档。
+  **评论、任务、Web 链接** – 指定是否爬取这些类型的内容。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **包含和排除筛选条件** - 指定是包含还是排除某些 Box 文件和文件夹。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **用户上下文筛选和访问控制** - 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Box 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

------

## 了解详情
<a name="box-learn-more"></a>

要了解有关Amazon Kendra与 Box 数据源集成的更多信息，请参阅：
+ [Amazon KendraBox 连接器入门](https://aws.amazon.com/blogs/machine-learning/getting-started-with-the-amazon-kendra-box-connector/)

## 注意
<a name="box-notes"></a>
+ 启用访问控制列表 (ACLs) 后，由于 Box API 的限制，“仅同步新内容或修改内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。

# Confluence
<a name="data-source-confluence"></a>

Confluence 是一款协作式工作管理工具，专为共享、存储和处理项目规划、软件开发和产品管理而设计。 Amazon Kendra 同时支持 Confluence Server/Data 中心和 Confluence Cloud。您可以使用索引 Amazon Kendra 以下 Confluence 实体：
+ **空间** – 用于组织相关内容的顶级指定区域。每个空间都可作为一个容器，能够容纳多个页面、博客和附件。
+ **页面** – 用户在其中创建和管理内容的空间中的文档。页面既可以包含文本、图像、表格和多媒体元素，也可以包含嵌套子页面。每个页面都被视为一个文档。
+ **博客** – 与页面相似的内容，通常用于更新或公告。每篇博客文章都被视为一个文档。
+ **评论** – 允许用户就页面或博客文章中的特定内容提供反馈或参与讨论。
+ **附件** – 上传到 Confluence 中页面或博客文章的文件，例如图像、文档或其他类型的文件。

默认情况下， Amazon Kendra 不索引 Confluence 档案和个人空间。在创建数据来源时，您可以选择为它们编制索引。如果您不想 Amazon Kendra 为空间编制索引，请在 Confluence 中将其标记为私有。

您可以使用[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)、API 或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Confluence 数据源。[ConfluenceConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ConfluenceConfiguration.html)

Amazon Kendra 有两个版本的 Confluence 连接器。支持以下功能。

****Confluence 连接器 V2.0/API [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)****
+ 字段映射
+ 用户访问控制
+ 包含/排除模式
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

****Confluence 连接器 V1.0/ [ConfluenceConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ConfluenceConfiguration.html)API**（不再支持）**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ （仅适用于 Confluence Server）虚拟私有云（VPC）

**注意**  
Confluence 连接器 V1.0/ ConfluenceConfiguration API 于 2023 年结束。我们建议迁移到或使用 Confluence 连接器 V2.0/API。 TemplateConfiguration 

要对 Amazon Kendra Confluence 数据源连接器进行故障排除，请参阅。[数据来源故障排除](troubleshooting-data-sources.md)

**Topics**
+ [ACLs in Confluence 连接器](#data-source-confluence-acls)
+ [Confluence 连接器 V2.0](data-source-v2-confluence.md)
+ [Confluence 连接器 V1.0](data-source-v1-confluence.md)

## ACLs in Confluence 连接器
<a name="data-source-confluence-acls"></a>

连接器支持抓取访问控制列表 (ACLs)，并在适用时根据数据源识别信息。如果您对不带索引的文档进行索引 ACLs，则所有文档都被视为公开。使用索引文档可 ACLs 确保数据安全。

 Amazon Kendra Confluence 连接器会扫描空间以收集页面和博客文章以及它们。 ACLs如果没有对页面或博客应用限制，则连接器将从其空间继承权限。如果对某个页面应用了特定的用户或组限制，则只有这些用户才能访问该页面。如果页面是嵌套的，若未应用任何限制，那么嵌套页面将继承父页面的权限。类似的权限模型适用于博客；但 Confluence 不支持嵌套博客。

此外， Amazon Kendra Confluence connector 还会抓取每个已配置空间的用户主体信息（本地用户别名、本地组和联合组身份配置）及其权限。

**注意**  
Confluence Cloud 连接器不支持爬取宏、白板或数据库。

每次抓取您的数据源内容时， Amazon Kendra Confluence 连接器都会更新 ACL 的更改。要确保适当的用户可以访问适当的内容，请定期重新同步您的数据来源以捕获任何 ACL 更新。

# Confluence 连接器 V2.0
<a name="data-source-v2-confluence"></a>

Confluence 是一款协作式工作管理工具，专为共享、存储和处理项目规划、软件开发和产品管理而设计。您可以使用 Amazon Kendra 索引 Confluence 空间、页面（包括嵌套页面）、博客以及已编入索引的页面和博客的评论和附件。

要对 Amazon Kendra Confluence 数据源连接器进行故障排除，请参阅。[数据来源故障排除](troubleshooting-data-sources.md)

**Topics**
+ [支持的功能](#supported-features-v2-confluence)
+ [先决条件](#prerequisites-v2-confluence)
+ [连接说明](#data-source-procedure-v2-confluence)

## 支持的功能
<a name="supported-features-v2-confluence"></a>

Amazon Kendra Confluence 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除模式
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v2-confluence"></a>

在使用 Amazon Kendra 索引您的 Confluence 数据源之前，请先在您的 Confluence 和账户中进行这些更改。 AWS 

**在 Confluence 中，请确保：**
+ 已复制 Confluence 实例的 URL。例如：*https://example.confluence.com*、或*https://www.example.confluence.com/*、或*https:// atlassian.net/*。您需要 Confluence 实例 URL 才能连接到 Amazon Kendra。

  如果您使用的是 Confluence Cloud，则您的主机网址必须以结尾。*atlassian.net/*
**注意**  
**不**支持以下 URL 格式：  
*https://example.confluence.com/xyz*
*https://www.example.confluence.com//wiki/spacekey/xxx*
*https://atlassian.net/xyz*
**注意**  
（本地/服务器） Amazon Kendra 会检查中 AWS Secrets Manager 包含的端点信息是否与数据源配置详细信息中指定的端点信息相同。这有助于防止出现[混淆代理人问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)，这是一个安全问题，即用户无权执行操作，但可以将 Amazon Kendra 作为代理来访问配置的密钥和执行操作。如果以后更改端点信息，则必须创建一个新密钥来同步此信息。
+ 配置了包含用户名（用于登录 Confluence 的电子邮件 ID）和密码（以 Confluence API 令牌作为密码）的基本身份验证凭证。请参阅 [Manage API tokens for your Atlassian account](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/#Create-an-API-token)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **可选：**已配置包含 Confluence 应用程序密钥、Confluence 应用程序密钥、Confluence 访问令牌和 Confluence 刷新令牌的 OAuth 2.0 证书，允许连接到你的 Confluence 实例。 Amazon Kendra 如果您的访问令牌过期，则可以使用刷新令牌重新生成访问令牌和刷新令牌对。或者，您可以重复授权过程。有关访问令牌的更多信息，请参阅[管理 OAuth 访问令牌](https://support.atlassian.com/confluence-cloud/docs/manage-oauth-access-tokens/)。
+ （仅适用于 Confluence Server/Data 中心）**可选：**在 Confluence 中配置了个人访问令牌 (PAT)。请参阅 [Using Personal Access Tokens](https://confluence.atlassian.com/enterprise/using-personal-access-tokens-1026032365.html)。

**在你的 AWS 账户，请确保你有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 将您的 Confluence 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将 Confluence 数据源连接至时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥。 Amazon Kendra如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v2-confluence"></a>

 Amazon Kendra 要连接到您的 Confluence 数据源，您必须提供 Confluence 数据源的必要详细信息， Amazon Kendra 以便访问您的数据。如果您尚未配置 Confluence，请参阅。 Amazon Kendra [先决条件](#prerequisites-v2-confluence)

------
#### [ Console ]

**连接到 Con Amazon Kendra fluence** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Confluence 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Confluence 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，选择 Confluence Cl **oud 或 Confluenc** **e Server/Data ** Center。

   1. **Confluence URL** - 输入 Confluence 主机 URL。例如 *https://example.confluence.com*。

   1. （仅适用于 Confluence Server/Data 中心）**SSL 证书位置-*可选*-** 输入 Confluence Server 的 SSL 证书文件的 Amazon S3 路径。

   1. （仅适用于 Conflu Server/Data ence Center）**Web 代理-*可选*-** 输入 Web 代理主机名（不带`http://`或`https://`协议）和端口号（主机 URL 传输协议使用的端口）。端口号应为介于 0 到 65535 之间的数值。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证** **-选择**基本身份验证、**Oauth 2.0 身份**验证**或（仅适用于 Confluence Cent Server/Data er）个人访问令牌身份验证。**

   1. **AWS Secrets Manager 密钥** - 选择现有密钥或创建新的 Secrets Manager 密钥来存储您的 Confluence 身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。在窗口中输入以下信息：

      1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Confluence-” 会自动添加到您的密钥名称中。

      1. 如果使用**基本身份验证**，请输入您在 Confluence 中配置的密钥名称、用户名和密码（以 Confluence API 令牌作为密码）。

         如果使用 **OAuth2.0 身份验证**-输入您在 Confluence 中配置的密钥名称、应用程序密钥、应用程序密钥、访问令牌和刷新令牌。

         （仅限 Confluence Server/Data 中心）如果使用**个人访问令牌身份验证**，请输入您在 Confluence 中配置的密钥名称和 Confluence 令牌。

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM ro** le —选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，对于**同步内容** – 选择从以下内容类型进行同步：页面、页面评论、页面附件、博客、博客评论、博客附件、个人空间和存档空间。
**注意**  
只有当您选择同步**页面**时，才能选择页面评论和页面附件。只有当您选择同步**博客**时，才能选择博客评论和博客附件。
**重要**  
如果您未在**其他配置**中指定空间键正则表达式模式，则默认情况下将爬取所有页面和博客。

   1. 在**其他配置**中，对于**最大文件大小**-在中指定 Amazon Kendra 要爬 MBs 行的文件大小限制。 Amazon Kendra 将仅抓取您定义的大小限制内的文件。默认文件大小为 50 MB。最大文件大小应大于 0 MB 且小于或等于 50 MB。

      对于**空间正则表达式模式** – 使用以下命令指定是在索引中包含还是排除特定空间：
      + 空格键（例如，*my-space-123*）
**注意**  
如果您未指定空间键正则表达式模式，则默认情况下将爬取所有页面和博客。
      + 网址（例如，*.\$1/MySite/MyDocuments/*）
      + 文件类型（例如，*.\$1\$1.pdf, .\$1\$1.txt*）

      对于**实体标题正则表达式模式** - 指定正则表达式模式以按标题包含或排除某些博客、页面、评论和附件。
**注意**  
如果要包含或排除对特定页面或子页面的爬取，则可以使用页面标题正则表达式模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。要添加自定义数据来源字段，请创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接到 Con Amazon Kendra fluence**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-confluence-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `CONFLUENCEV2`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **主机 URL** - 指定 Confluence 主机 URL 实例。例如 *https://example.confluence.com*。
+ **同步模式** – 指定当数据来源内容发生变化时 Amazon Kendra 更新索引的方式。首次与同步数据源时， Amazon Kendra 默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`每次数据源与索引同步时，仅对新的、修改过的和已删除的内容编制索引。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
+ **身份验证类型** - 指定身份验证的类型是 `Basic`、`OAuth2` 还是（仅限 Confluence Server）`Personal-token`。
+ （可选，仅限 Confluence Server）**SSL 证书位置** - 指定用于存储 SSL 证书的 `S3bucketName` 和 `s3certificateName`。
+ **亚马逊秘密资源名称 (ARN)-提供包含您**在 Confluence 中配置的身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。如果您使用基本身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "username": "email ID or user name",
      "password": "Confluence API token"
  }
  ```

  如果您使用 OAuth 2.0 身份验证，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "confluenceAppKey": "app key",
      "confluenceAppSecret": "app secret",
      "confluenceAccessToken": "access token",
      "confluenceRefreshToken": "refresh token"
  }
  ```

  （仅限 Confluence Server）如果您使用基本身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "hostUrl": "Confluence Server host URL",
      "username": "Confluence Server user name",
      "password": "Confluence Server password"
  }
  ```

  （仅限 Confluence Server）如果您使用个人访问令牌身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "hostUrl": "Confluence Server host URL",
      "patToken": "personal access token"
  }
  ```
+ **IAM 角色** —指定`RoleArn`何时调用`CreateDataSource`以向 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及致电 Confluence 连接器 APIs 所需的公众的权限，以及。 Amazon Kendra有关更多信息，请参阅 [Confluence 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **文件大小** – 指定要爬取的最大文件大小。
+  **文档/内容类型** - 指定是否爬取页面、页面评论、页面附件、博客、博客评论、博客附件、空间和存档空间。
+ **包含和排除筛选条件** - 指定是包含还是排除某些空间、页面、博客及其评论和附件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **Web 代理** - 如果您想通过 Web 代理连接到您的 Confluence URL 实例，请指定您的 Web 代理信息。您可以将此选项用于 Confluence Server。
+ **访问控制列表（ACL）**- 如果您有 ACL 并想将其用于访问控制，请选择是否爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Confluence 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Confluence 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-confluence-schema)。

------

### 注意
<a name="confluence-notes"></a>
+ 个人访问令牌（PAT）不适用于 Confluence Cloud。

# Confluence 连接器 V1.0
<a name="data-source-v1-confluence"></a>

Confluence 是一款协作式工作管理工具，专为共享、存储和处理项目规划、软件开发和产品管理而设计。您可以使用 Amazon Kendra 索引 Confluence 空间、页面（包括嵌套页面）、博客以及已编入索引的页面和博客的评论和附件。

**注意**  
Confluence 连接器 V1.0/ ConfluenceConfiguration API 于 2023 年结束。我们建议迁移到或使用 Confluence 连接器 V2.0/API。 TemplateConfiguration 

要对 Amazon Kendra Confluence 数据源连接器进行故障排除，请参阅。[数据来源故障排除](troubleshooting-data-sources.md)

**Topics**
+ [支持的功能](#supported-features-v1-confluence)
+ [先决条件](#prerequisites-v1-confluence)
+ [连接说明](#data-source-procedure-v1-confluence)
+ [了解详情](#confluence-v1-learn-more)

## 支持的功能
<a name="supported-features-v1-confluence"></a>

Amazon Kendra Confluence 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ （仅适用于 Confluence Server）虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v1-confluence"></a>

在使用 Amazon Kendra 索引您的 Confluence 数据源之前，请先在您的 Confluence 和账户中进行这些更改。 AWS 

**在 Confluence 中，请确保：**
+ 通过以下 Amazon Kendra 方式授予查看您的 Confluence 实例中所有内容的权限：
  +  Amazon Kendra 成为`confluence-administrators`群组成员。
  + 授予所有现有空间、博客和页面的站点管理员权限。
+ 复制 Confluence 实例的 URL。
+ **对于 SSO（单点登录）用户**：在 Confluence 数据中心配置 Confluence **身份验证方法**时，激活了**显示登录页面**以输入用户名和密码。
+ **对于 Confluence Server**
  + 记下了您的基本身份验证凭证，其中包含要连接到 Amazon Kendra的 Confluence 管理账户用户名和密码。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
  + **可选：**在您的 Confluence 账户中生成了要连接的个人访问令牌。 Amazon Kendra有关更多信息，请参阅[有关生成个人访问令牌的 Confluence 文档](https://confluence.atlassian.com/enterprise/using-personal-access-tokens-1026032365.html)。
+ **对于 Confluence Cloud**
  + 记下了您的基本身份验证凭证，其中包含要连接到 Amazon Kendra的 Confluence 管理账户用户名和密码。
+ 在 Confluence 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的 AWS 账户，请确保你有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 将您的 Confluence 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将 Confluence 数据源连接至时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥。 Amazon Kendra如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v1-confluence"></a>

 Amazon Kendra 要连接到您的 Confluence 数据源，您必须提供您的 Confluence 凭据的详细信息， Amazon Kendra 以便访问您的数据。如果您尚未配置 Confluence，请参阅。 Amazon Kendra [先决条件](#prerequisites-v1-confluence)

------
#### [ Console ]

**连接到 Con Amazon Kendra fluence** 

1. 登录 AWS 管理控制台并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**入门**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 ** Confluence 连接器 V1.0**，然后选择**添加数据来源**。

1. 在**指定数据来源详细信息**页面上输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 选择 **Confluence Cloud** 或 **Confluence Server**。

   1. 如果选择 **Confluence Cloud**，请输入以下信息：

      1. **Confluence URL** - 您的 Confluence URL。

      1. AWS Secrets Manager s@@ **ecret** —选择现有密钥或创建新 Secrets Manager 密钥来存储您的 Confluence 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

         1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Confluence-” 会自动添加到您的密钥名称中。

           1. 对于**用户名**和**密码** – 输入您的 Confluence 用户名和密码。

           1. 选择**保存身份验证**。

   1. 如果选择 **Confluence Server**，请输入以下信息：

      1. **Confluence URL** - 您的 Confluence 用户名和密码。

      1. （可选）对于 **Web 代理** - 请输入以下信息：

         1.  **主机名** - 您的 Confluence 账户的主机名。

         1.  **端口号** - 主机 URL 传输协议使用的端口。

      1. 对于**身份验证**，请选择**基本身份验证**或（仅限 Confluence Server）**个人访问令牌**。

      1. AWS Secrets Manager s@@ **ecret** —选择现有密钥或创建新 Secrets Manager 密钥来存储您的 Confluence 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

         1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Confluence-” 会自动添加到您的密钥名称中。

           1. 对于**用户名**和**密码** - 输入您在 Confluence 中配置的身份验证凭证值。如果使用基本身份验证，请使用您的 Confluence 用户名（电子邮件 ID）和密码（API 令牌）。如果使用个人访问令牌，请输入您在 Confluence 账户中配置的**个人访问令牌**的详细信息。

           1. 保存并添加您的密钥。

   1. **IAM ro** le —选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 对于**包括个人空间**和**包括存档空间** - 选择要包含在此数据来源中的可选空间类型。

   1. 对于**其他配置** - 指定正则表达式模式以包含或排除某些文件。最多可以添加 100 个模式。

   1. 您还可以选择**在所选空间内爬取附件**。

   1. 在 “**同步运行计划**” 中，“**频率**”-选择与数据源同步的频率。 Amazon Kendra 

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 对于 **Spac** **e、Page**、**Blog**-从 Amazon Kendra 生成的默认数据源字段或其他**建议的字段映射**中选择以添加索引字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接到 Con Amazon Kendra fluence**

您必须使用 [ConfluenceConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ConfluenceConfiguration.html)API 指定以下内容：
+ **Confluence 版本** - 指定您用作 `CLOUD` 或 `SERVER` 的 Confluence 实例的版本。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Confluence 身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。

  如果您使用的是 Confluence Server，则可以使用您的 Confluence 用户名和密码或您的个人访问令牌作为身份验证凭证。

  如果您使用 Confluence 用户名和密码作为身份验证凭证，您将在 Secrets Manager 密钥中以 JSON 结构的形式存储以下凭证：

  ```
  {
      "username": "user name",
      "password": "password"
  }
  ```

  如果您使用个人访问令牌连接 Confluence Server Amazon Kendra，则可以将以下凭据作为 JSON 结构存储在您的 Secrets Manager 密钥中：

  ```
  {
      "patToken": "personal access token"
  }
  ```

  如果您使用 Confluence Cloud，则可以使用您的 Confluence 用户名和在 Confluence 配置的 API 令牌作为密码。您将以下凭证作为 JSON 结构存储在您的 Secrets Manager 密钥中：

  ```
  {
      "username": "user name",
      "password": "API token"
  }
  ```
+ **IAM 角色** —指定`RoleArn`何时调用`CreateDataSource`以向 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及致电 Confluence 连接器 APIs 所需的公众的权限，以及。 Amazon Kendra有关更多信息，请参阅 [Confluence 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **Web 代理** - 是否通过 Web 代理连接到您的 Confluence URL 实例。您可以将此选项用于 Confluence Server。
+ （仅适用于 Confluence Server）**虚拟私有云（VPC）**- 在数据来源配置中指定 `VpcConfiguration`。请参阅[配置 Amazon Kendra 以使用 VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。
+  **包含和排除筛选条件** - 指定用于包含或排除特定空间、博客文章、页面、空间和附件的正则表达式。如果您选择为附件编制索引，则仅对已编入索引的页面和博客的附件编制索引。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **字段映射** - 选择将 Confluence 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。

------

## 了解详情
<a name="confluence-v1-learn-more"></a>

要了解有关 Amazon Kendra 与 Confluence 数据源集成的更多信息，请参阅：
+ [配置您的 Amazon Kendra Confluence 服务器连接器](https://aws.amazon.com/blogs/machine-learning/configuring-your-amazon-kendra-confluence-server-connector/)

# 自定义数据来源连接器
<a name="data-source-custom"></a>

如果 Amazon Kendra 没有为您的存储库提供数据来源连接器，请使用自定义数据来源。即使您无法使用 Amazon Kendra 数据来源同步存储库，也可以使用 Amazon Kendra 来查看数据来源提供的相同运行历史指标。使用它可以在 Amazon Kendra 数据来源和自定义数据来源之间创建一致的同步监控体验。具体而言，使用自定义数据来源来查看您使用 [BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html) 和 [BatchDeleteDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchDeleteDocument.html) API 创建的数据来源连接器的同步指标。

要对 Amazon Kendra 数据来源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

创建自定义数据来源时，您可以完全控制要编制索引的文档的选择方式。Amazon Kendra 仅提供可用于监控 DATA SOLOG SYNC 作业的指标信息。您必须创建并运行用于确定数据来源索引文档的爬网程序。

您必须使用 [Document](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html) 对象，以及 [DocumentAttribute](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DocumentAttribute.html) 中的 `_source_uri` 指定文档的主标题，从而将 `DocumentTitle` 和 `DocumentURI` 包含在 `Query` 结果的响应中。

您可以使用控制台或使用 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html) API 为自定义数据来源创建标识符。要使用控制台，请为您的数据来源命名，并可选择提供描述和资源标签。创建数据来源后，将显示数据来源 ID。复制此 ID，以便在将数据来源与索引同步时使用。

![\[Form for specifying data source details, including name, description, and optional tags.\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/images/CustomDataSource.png)


您还可以使用 `CreateDataSource` API 创建自定义数据来源。API 会返回一个 ID，供您在同步数据来源时使用。使用 `CreateDataSource` API 创建自定义数据来源时，无法设置 `Configuration`、`RoleArn` 或 `Schedule` 参数。如果您设置了这些参数，则 Amazon Kendra 会返回 `ValidationException` 异常。

要使用自定义数据来源，请创建一个负责更新 Amazon Kendra 索引的应用程序。该应用程序依赖于您创建的爬网程序。爬网程序会读取存储库中的文档并确定应将哪些文档发送到 Amazon Kendra。您的应用程序应执行以下步骤：

1. 爬取您的存储库，列出存储库中添加、更新或删除的文档。

1. 调用 [StartDataSourceSyncJob](https://docs.aws.amazon.com/kendra/latest/APIReference/API_StartDataSourceSyncJob.html) API 发出同步作业正在启动的信号。您需要提供一个数据来源 ID 来标识正在同步的数据来源。Amazon Kendra 会返回用于标识特定同步任务的执行 ID。

1. 调用 [BatchDeleteDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchDeleteDocument.html) API 从索引中删除文档。您可以提供数据来源 ID 和执行 ID 来标识正在同步的数据来源以及与此更新关联的作业。

1. 调用 [StopDataSourceSyncJob API](https://docs.aws.amazon.com/kendra/latest/APIReference/API_StopDataSourceSyncJob.html) 发出同步任务结束的信号。调用 `StopDataSourceSyncJob` API 后，关联的执行 ID 不再有效。

1. 使用索引调用 [ListDataSourceSyncJobs](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListDataSourceSyncJobs.html) API，列出数据来源的同步任务并查看同步作业的指标。

结束同步作业后，您可以开始新的同步作业。可能需要一段时间才能将所有提交的文档添加到索引中。使用 `ListDataSourceSyncJobs` API 查看同步任务的状态。如果同步作业返回的 `Status` 为 `SYNCING_INDEXING`，则某些文档仍在编制索引。当上一个作业的状态为 `FAILED` 或 `SUCCEEDED` 时，您可以启动新的同步作业。

调用 `StopDataSourceSyncJob` API 后，您不能在调用 `BatchPutDocument` 或 `BatchDeleteDocument` API 时使用同步任务标识符。如果您这样做，则提交的所有文档都将在 API 的 `FailedDocuments` 响应消息中返回。

## 必需的属性
<a name="custom-required-attributes"></a>

当您使用 `BatchPutDocument` API 向 Amazon Kendra 提交文档时，每个文档都需要两个属性来标识其所属的数据来源和同步运行。要将自定义数据来源的文档正确映射到 Amazon Kendra 索引，您必须提供以下两个属性：
+ `_data_source_id` - 数据来源的标识符。当您使用控制台或 `CreateDataSource` API 创建数据来源时，会返回此值。
+ `_data_source_sync_job_execution_id` - 同步运行的标识符。当您开始与 `StartDataSourceSyncJob` API 进行索引同步时，会返回该值。

以下是使用自定义数据来源为文档编制索引所需的 JSON。

```
{
    "Documents": [
        {
            "Attributes": [
                {
                    "Key": "_data_source_id",
                    "Value": {
                        "StringValue": "data source identifier"
                    }
                },
                {
                    "Key": "_data_source_sync_job_execution_id",
                    "Value": {
                        "StringValue": "sync job identifier"
                    }
                }
            ],
            "Blob": "document content",
            "ContentType": "content type",
            "Id": "document identifier",
            "Title": "document title"
        }
    ],
    "IndexId": "index identifier",
    "RoleArn": "IAM role ARN"
}
```

使用 `BatchDeleteDocument` API 从索引中移除文档时，需要在 `DataSourceSyncJobMetricTarget` 参数中指定以下两个字段：
+ `DataSourceId` - 数据来源的标识符。当您使用控制台或 `CreateDataSource` API 创建数据来源时，会返回此值。
+ `DataSourceSyncJobId` - 同步运行的标识符。当您开始与 `StartDataSourceSyncJob` API 进行索引同步时，会返回该值。

以下是使用 `BatchDeleteDocument` API 从索引中删除文档所需的 JSON。

```
{
    "DataSourceSyncJobMetricTarget": {
        "DataSourceId": "data source identifier",
        "DataSourceSyncJobId": "sync job identifier"
    },
    "DocumentIdList": [
        "document identifier"
    ],
    "IndexId": "index identifier"
}
```

## 查看指标
<a name="custom-metrics"></a>

同步任务完成后，您可以使用 [DataSourceSyncJobMetrics](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DataSourceSyncJobMetrics.html) API 来获取与同步任务相关的指标。使用它来监控您的自定义数据来源同步。

如果您多次提交同一个文档，无论是作为 `BatchPutDocument` API、`BatchDeleteDocument` API 的一部分，还是为添加和删除提交该文档，该文档在指标中仅计入一次。
+ `DocumentsAdded` - 使用与首次添加到索引中的此同步作业关联的 `BatchPutDocument` API 提交的文档数量。如果在同步中为添加多次提交文档，则该文档在指标中仅计入一次。
+ `DocumentsDeleted` - 使用与从索引中删除的此同步作业关联的 `BatchDeleteDocument` API 提交的文档数量。如果在同步中为删除多次提交文档，则该文档在指标中仅计入一次。
+ `DocumentsFailed` - 与该同步作业关联但编制索引失败的文档数量。Amazon Kendra 已接受为这些文档编制索引，但无法编制索引或已删除。如果 Amazon Kendra 未接受某个文档，则该文档的标识符将在 `BatchPutDocument` 和 `BatchDeleteDocument` API 的 `FailedDocuments` 响应属性中返回。
+ `DocumentsModified` - 使用与在 Amazon Kendra 索引中修改的此同步作业关联的 `BatchPutDocument` API 提交的已修改文档的数量。

Amazon Kendra 在为文档编制索引时也会发出 Amazon CloudWatch 指标。有关更多信息，请参阅[使用 Amazon CloudWatch 监控 Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/cloudwatch-metrics.html)。

Amazon Kendra 不返回自定义数据来源的 `DocumentsScanned` 指标。它还会发出文档[Amazon Kendra 数据来源的指标](https://docs.aws.amazon.com/kendra/latest/dg/cloudwatch-metrics.html#cloudwatch-metrics-data-source)中列出的 CloudWatch 指标。

## 了解更多
<a name="custom-learn-more"></a>

要了解有关将 Amazon Kendra 与自定义数据来源集成的更多信息，请参阅：
+ [将自定义数据来源添加到 Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/adding-custom-data-sources-to-amazon-kendra/)

# 自定义数据来源（Java）
<a name="custom-java-sample"></a>

以下代码提供了使用 Java 实现自定义数据来源的示例。该程序首先创建自定义数据来源，然后将新添加至索引的文档与自定义数据来源同步。

以下代码演示了如何创建和使用自定义数据来源。当您在应用程序中使用自定义数据来源时，无需在每次将索引与数据来源同步时都创建新的数据来源（一次性流程）。您可以使用索引 ID 和数据来源 ID 来同步数据。

```
package com.amazonaws.kendra;

import java.util.concurrent.TimeUnit;
import software.amazon.awssdk.services.kendra.KendraClient;
import csoftware.amazon.awssdk.services.kendra.model.BatchPutDocumentRequest;
import csoftware.amazon.awssdk.services.kendra.model.BatchPutDocumentResponse;
import software.amazon.awssdk.services.kendra.model.CreateDataSourceRequest;
import software.amazon.awssdk.services.kendra.model.CreateDataSourceResponse;
import software.amazon.awssdk.services.kendra.model.DataSourceType;
import software.amazon.awssdk.services.kendra.model.Document;
import software.amazon.awssdk.services.kendra.model.ListDataSourceSyncJobsRequest;
import software.amazon.awssdk.services.kendra.model.ListDataSourceSyncJobsResponse;
import software.amazon.awssdk.services.kendra.model.StartDataSourceSyncJobRequest;
import software.amazon.awssdk.services.kendra.model.StartDataSourceSyncJobResponse;
import software.amazon.awssdk.services.kendra.model.StopDataSourceSyncJobRequest;
import software.amazon.awssdk.services.kendra.model.StopDataSourceSyncJobResponse;

public class SampleSyncForCustomDataSource {
  public static void main(String[] args) {
    KendraClient kendra = KendraClient.builder().build();

    String myIndexId = "yourIndexId";
    String dataSourceName = "custom data source";
    String dataSourceDescription = "Amazon Kendra custom data source connector"
	
    // Create custom data source
    CreateDataSourceRequest createDataSourceRequest = CreateDataSourceRequest
        .builder()
        .indexId(myIndexId)
        .name(dataSourceName)
        .description(dataSourceDescription)
        .type(DataSourceType.CUSTOM)
        .build();
    	
    CreateDataSourceResponse createDataSourceResponse = kendra.createDataSource(createDataSourceRequest);
    System.out.println(String.format("Response of creating data source: %s", createDataSourceResponse));
	
    // Get the data source ID from createDataSourceResponse
    String dataSourceId = createDataSourceResponse.Id();

    // Wait for the custom data source to become active
    System.out.println(String.format("Waiting for Amazon Kendra to create the data source %s", dataSourceId));
    // You can use the DescribeDataSource API to check the status
    DescribeDataSourceRequest describeDataSourceRequest = DescribeDataSourceRequest
        .builder()
        .indexId(myIndexId)
        .id(dataSourceId)
        .build();

    while (true) {
        DescribeDataSourceResponse describeDataSourceResponse = kendra.describeDataSource(describeDataSourceRequest);

        DataSourceStatus status = describeDataSourceResponse.status();
        System.out.println(String.format("Creating data source. Status: %s", status));
        if (status != DataSourceStatus.CREATING) {
            break;
        }
        
        TimeUnit.SECONDS.sleep(60);
    }
    
    // Start syncing yor data source by calling StartDataSourceSyncJob and providing your index ID 
    // and your custom data source ID
    System.out.println(String.format("Synchronize the data source %s", dataSourceId));
    StartDataSourceSyncJobRequest startDataSourceSyncJobRequest = StartDataSourceSyncJobRequest
        .builder()
        .indexId(myIndexId)
        .id(dataSourceId)
        .build();
    StartDataSourceSyncJobResponse startDataSourceSyncJobResponse = kendra.startDataSourceSyncJob(startDataSourceSyncJobRequest);
    
    // Get the  sync job execution ID from startDataSourceSyncJobResponse
    String executionId = startDataSourceSyncJobResponse.ExecutionId();
	System.out.println(String.format("Waiting for the data source to sync with the index %s for execution ID %s", indexId, startDataSourceSyncJobResponse.executionId()));
    
    // Add 2 documents uploaded to S3 bucket to your index using the BatchPutDocument API
    // The added documents should sync with your custom data source
    Document pollyDoc = Document
        .builder()
        .s3Path(
            S3Path.builder()
            .bucket("amzn-s3-demo-bucket")
            .key("what_is_Amazon_Polly.docx")
            .build())
        .title("What is Amazon Polly?")
        .id("polly_doc_1")
        .build();
    
    Document rekognitionDoc = Document
        .builder()
        .s3Path(
            S3Path.builder()
            .bucket("amzn-s3-demo-bucket")
            .key("what_is_amazon_rekognition.docx")
            .build())
        .title("What is Amazon rekognition?")
        .id("rekognition_doc_1")
        .build();
    
    BatchPutDocumentRequest batchPutDocumentRequest = BatchPutDocumentRequest
        .builder()
        .indexId(myIndexId)
        .documents(pollyDoc, rekognitionDoc)
        .build();
    
    BatchPutDocumentResponse result = kendra.batchPutDocument(batchPutDocumentRequest);
    System.out.println(String.format("BatchPutDocument result: %s", result));
    
    // Once custom data source synced, stop the sync job using the StopDataSourceSyncJob API
    StopDataSourceSyncJobResponse stopDataSourceSyncJobResponse = kendra.stopDataSourceSyncJob(
        StopDataSourceSyncJobRequest()
            .indexId(myIndexId)
            .id(dataSourceId)
    );
	
	// List your sync jobs
    ListDataSourceSyncJobsRequest listDataSourceSyncJobsRequest = ListDataSourceSyncJobsRequest
        .builder()
        .indexId(myIndexId)
        .id(dataSourceId)
        .build();
    
    while (true) {
        ListDataSourceSyncJobsResponse listDataSourceSyncJobsResponse = kendra.listDataSourceSyncJobs(listDataSourceSyncJobsRequest);
        DataSourceSyncJob job = listDataSourceSyncJobsResponse.history().get(0);
        System.out.println(String.format("Status: %s", job.status()));
    }
  }
}
```

# Dropbox
<a name="data-source-dropbox"></a>

Dropbox 是一项文件托管服务，提供云存储、文档整理和文档模板服务。如果您是 Dropbox 用户，则可以使用Amazon Kendra索引您的 Dropbox 文件、Dropbox Paper、Dropbox Paper 模板和存储的网页快捷方式。您还可以配置Amazon Kendra为索引特定的 Dropbox 文件、Dropbox Paper、Dropbox Paper 模板和存储的网页快捷方式。

Amazon Kendra同时支持 Dropbox Business 版 Dropbox 和

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Dropbox 数据源。

要对 Amazon Kendra Dropbox 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-dropbox)
+ [先决条件](#prerequisites-dropbox)
+ [连接说明](#data-source-procedure-dropbox)
+ [了解详情](#dropbox-learn-more)
+ [注意](#dropbox-notes)

## 支持的功能
<a name="supported-features-dropbox"></a>

Amazon KendraDropbox 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-dropbox"></a>

在使用Amazon Kendra索引 Dropbox 数据源之前，请在您的 Dropbox 和AWS帐户中进行这些更改。

**在 Dropbox 中，请确保：**
+ 已创建 Dropbox Advanced 账户并设置了管理员用户。
+ 已配置一个具有唯一**应用程序名称**的 Dropbox 应用程序，并激活了**作用域访问权限**。请参阅[有关创建应用程序的 Dropbox 文档](https://www.dropbox.com/developers/reference/getting-started#app%20console)。
+ 在 Dropbox 控制台上激活了 **Dropbox 的完整权限**，并添加了以下权限：
  + files.content.read
  + files.metadata.read
  + sharing.read
  + file\$1requests.read
  + groups.read
  + team\$1info.read
  + team\$1data.content.read
+ 已记下您的 Dropbox 应用程序键、Dropbox 应用程序密钥和适用于基本身份验证凭证的 Dropbox 访问令牌
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 已为您的 Dropbox 应用程序配置并复制临时的 Oauth 2.0 访问令牌。此令牌是临时性的，将在 4 小时后过期。请参阅有关[ OAuth 身份验证的 Dropbox 文档](https://developers.dropbox.com/oauth-guide)。
**注意**  
建议您创建永不过期的 Dropbox 刷新访问令牌，而不是依赖在 4 小时后过期的一次性访问令牌。刷新访问令牌是永久性的，永不过期，因此您将来可以继续同步数据来源。
+ **推荐：**已配置永不过期的 Dropbox 永久刷新令牌，Amazon Kendra以便在不中断的情况下继续同步您的数据源。请参阅[有关刷新令牌的 Dropbox 文档](https://developers.dropbox.com/oauth-guide)。
+ 在 Dropbox 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Dropbox 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Dropbox 数据源关联到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-dropbox"></a>

要Amazon Kendra连接到您的 Dropbox 数据源，您必须提供 Dropbox 数据源的必要详细信息，这样Amazon Kendra他们才能访问您的数据。如果您尚未配置 DropboxAmazon Kendra，请参阅[先决条件](#prerequisites-dropbox)。

------
#### [ Console ]

**连接到 Drop Amazon Kendra box** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Dropbox 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Dropbox 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证令牌的类型** - 选择永久令牌（推荐）或临时访问令牌。

   1. **AWS Secrets Manager密钥**-选择现有密钥或创建新Secrets Manager密钥来存储您的 Dropbox 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Dropbox-” 会自动添加到您的密钥名称中。

         1. 对于**应用程序键**、**应用程序密钥**和令牌信息（永久令牌或临时令牌）- 输入您在 Dropbox 中配置的身份验证凭证值。

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 对于**选择实体或内容类型** - 选择要爬取的 Dropbox 实体或内容类型。

   1. 在**其他配置**中，对于**正则表达式模式** - 添加正则表达式模式以包含或排除某些文件。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **文件**、**Dropbox Pap** er 和 **Dropbox Paper 模板**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的默认数据源字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接到 Drop Amazon Kendra box**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-dropbox-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `DROPBOX`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **访问令牌类型** - 指定要对存储身份验证凭证的 AWS Secrets Manager 密钥使用永久访问令牌还是临时访问令牌。
**注意**  
建议您创建在 Dropbox 中永不过期的刷新访问令牌，而不是依赖在 4 小时后过期的一次性访问令牌。您可以在 Dropbox 开发者控制台中创建应用程序和刷新访问令牌，并在密钥中提供访问令牌。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Dropbox 帐户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "appKey": "Dropbox app key",
      "appSecret": "Dropbox app secret",
      "accesstoken": "temporary access token or refresh access token"
  }
  ```
+ **身份爬网程序** - 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+ **IAM角色** —指定`RoleArn`何时致电`CreateDataSource`为IAM角色提供访问您的Secrets Manager密钥的权限，以及致电 APIs 所需的公众访问 Dropbox 连接器和Amazon Kendra。有关更多信息，请参阅 [Dropbox 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **文档/内容类型** – 指定是否爬取 Dropbox 中的文件、Dropbox Paper 文档、Dropbox Paper 模板以及存储在 Dropbox 中的网页快捷方式。
+ **包含和排除筛选条件** - 指定是包含还是排除文件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **访问控制列表（ACL）**- 如果您有 ACL 并想将其用于访问控制，请选择是否爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。
+  **字段映射** - 选择将 Dropbox 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Dropbox 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-dropbox-schema)。

------

## 了解详情
<a name="dropbox-learn-more"></a>

要了解有关将 Amazon Kendra 与 Dropbox 数据来源集成的更多信息，请参阅：
+ [使用适用于 Amazon Kendra 的 Dropbox 连接器为 Dropbox 内容编制索引](https://aws.amazon.com/blogs/machine-learning/index-your-dropbox-content-using-the-dropbox-connector-for-amazon-kendra/)

## 注意
<a name="dropbox-notes"></a>
+ 启用访问控制列表 (ACLs) 后，由于 Dropbox API 的限制，“仅同步新内容或修改过的内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。

# Drupal
<a name="data-source-drupal"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍将为现有客户提供对 Drupal 连接器的完全支持。该连接器虽已不再面向新用户开放，但现有用户可继续无中断使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Drupal 是一个可用于创建网站和 Web 应用程序的开源内容管理系统（CMS）。你可以在 Drupal 中使用Amazon Kendra索引以下内容：
+ 内容 - 文章、基本页面、基本数据块、用户定义的内容类型、用户定义的数据块类型、自定义内容类型、自定义数据块类型
+ 评论 - 适用于任何内容类型和数据块类型
+ 附件 - 适用于任何内容类型和数据块类型

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Drupal 数据源。

要对 Amazon Kendra Drupal 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-drupal)
+ [先决条件](#prerequisites-drupal)
+ [连接说明](#data-source-procedure-drupal)
+ [注意](#drupal-notes)

## 支持的功能
<a name="supported-features-drupal"></a>

Amazon KendraDrupal 数据源连接器支持以下功能：
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-drupal"></a>

在使用Amazon Kendra索引 Drupal 数据源之前，请在您的 Drupal 和AWS帐户中进行这些更改。

**在 Drupal 中，请确保：**
+ 已创建一个 Drupal（标准）套件账户和一个具有管理员角色的用户。
+ 已复制 Drupal 站点名称并配置了主机 URL。例如 *https://<hostname>/<drupalsitename>*。
+ 已配置包含用户名（Drupal 网站登录用户名）和密码（Drupal 网站密码）的基本身份验证凭证。
+ **推荐：**已配置 OAuth 2.0 凭据令牌。使用此令牌以及您的 Drupal 密码授权、客户端 ID、客户端密钥、用户名（Drupal 网站登录用户名）和密码（Drupal 网站密码）连接到 Amazon Kendra。
+ 使用管理员角色在您的 Drupal 账户中添加了以下权限：
  + 管理数据块
  + 挂你数据块内容显示
  + 管理数据块内容字段
  + 管理数据块内容表达显示
  + 管理视图
  + 查看用户电子邮件地址
  + 查看自己的未发布内容
  + 查看页面修订
  + 查看文章修订
  + 查看所有修订
  + 查看管理主题
  + 访问内容
  + 访问内容概览
  + 访问注释
  + 搜索内容
  + 访问文件概览
  + 访问上下文链接
**注意**  
如果存在用户定义的内容类型或用户定义的数据块类型，或者任何视图和区块被添加到 Drupal 网站，则必须为其提供管理员访问权限。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Drupal 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Drupal 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-drupal"></a>

要Amazon Kendra连接到您的Drupal数据源，您必须提供您的Drupal凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未配置 Drupal，请参Amazon Kendra阅[先决条件](#prerequisites-drupal)。

------
#### [ Console ]

**要连接Amazon Kendra到 Drupal** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Drupal 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Drupal 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，对于**主机 URL** - 您的 Drupal 网站的主机 URL。例如 *https://<hostname>/<drupalsitename>*。

   1. **SSL 证书位置** - 输入您存储在 Amazon S3 存储桶中的 SSL 证书的路径。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. 对于**身份验证**-根据您的用例在**基本身份**验证和 **OAuth 2.0 身份验证**之间进行选择。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 Drupal 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. 如果已选择**基本身份验证**，请输入您复制的**密钥名称****、用户名**（Drupal 站点用户名）和**密码**（Drupal 站点密码），然后选择**保存和添加密钥**。

         1. **如果您选择了 **OAuth 2.0 身份验证**，请输入在您的 Drupal 帐户中生成的**密钥名称**、**用户**名（Drupal 站点用户名）、密码（Drupal 站点密码）、**客户**端 ID** 和客户机密**，然后选择**保存并**添加密钥。**

      1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 对于**同步范围**，从以下选项中进行选择：
**注意**  
当您选择爬取**文章**、**基本页面**和**基本数据块**时，它们的默认字段将自动同步。您也可以选择同步它们的评论、附件、自定义字段和其他自定义实体。

      1. 对于**选择实体**：
        +  **文章** - 选择是否爬取**文章**、文章评论、**评论**和**附件**。
        + **基本页面** - 选择是否爬取**基本页面**、页面**评论**及其**附件**。
        + **基本数据块** - 选择是否爬取**基本数据块**、数据块**评论**及其**附件**。
        + 您也可以选择添加**自定义内容类型**和**自定义数据块**。

   1. 对于**其他配置 - 可选**：
      + 对于**正则表达式模式** - 添加正则表达式模式以包含或排除特定的实体标题和文件名。最多可以添加 100 个模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 对于**内容**、**评论**和**附件**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Drupal**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-drupal-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `DRUPAL`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在 Drupal 账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。

  如果您使用基本身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "username": "user name",
      "password": "password"
  }
  ```

  如果您使用 OAuth 2.0 身份验证，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "username": "user name",
      "password": "password",
      "clientId": "client id",
      "clientSecret": "client secret"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`为IAM角色提供访问您的Secrets Manager密钥的权限以及呼叫 Drupal 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Drupal 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除筛选条件** - 您可以指定是否包括内容、评论和附件。您也可以指定正则表达式模式来包含或排除内容、评论和附件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Drupal 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Drupal 模板架构](ds-schemas.md#ds-drupal-schema)。

------

## 注意
<a name="drupal-notes"></a>
+ Drupal APIs 没有官方的限制限制。
+ Java SDKs 不适用于 Drupal。
+ 只能使用原生 JSON API 获取 Drupal 数据。
+ 无法爬取与任何 Drupal **视图**无关的内容类型。
+ 您需要管理员访问权限才能从 Drupal **数据块**中爬取数据。
+ 没有可用于使用 HTTP 动词创建用户定义的内容类型的 JSON API。
+ **文章**、**基本页面**、**基本数据块**、用户定义的内容类型和用户定义的数据块类型的文档正文和评论以 HTML 格式显示。如果 HTML 内容格式不正确，则与 HTML 相关的标签将出现在文档正文和注释中，并在 Amazon Kendra 搜索结果中可见。
+ 没有描述或正文的内容类型和**区块**类型不会被Amazon Kendra收录。只有此类**内容**或**区块**类型的**评论**和**附件**才会被提取到您的Amazon Kendra索引中。

# GitHub
<a name="data-source-github"></a>

GitHub 是一项用于软件开发的基于 Web 的托管服务，提供带有版本控制的代码存储和管理服务。您可以使用Amazon Kendra索引 GitHub 企业云 (SaaS) 和 GitHub 企业服务器（On Prem）存储库文件、议题和拉取请求、议题和拉取请求评论以及议题和拉取请求评论附件。您也可以选择包括或排除某些文件。

**注意**  
Amazon Kendra现在支持升级后的 GitHub 连接器。  
已为您自动完成控制台升级。您在控制台中新建的所有连接器都将使用升级后的架构。现在，如果您使用 API，则必须使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象而不是 `GitHubConfiguration` 对象来配置您的连接器。  
使用旧版控制台和 API 架构配置的连接器仍可照常运行，但您将无法编辑或更新它们。如果要编辑或更新连接器配置，必须新建一个连接器。  
我们建议您将连接器工作流程迁移至升级后的版本。使用旧版架构配置的连接器的支持预计将在 2024 年 6 月前终止。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 GitHub 数据源。

要对Amazon KendraGitHub 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-github)
+ [先决条件](#prerequisites-github)
+ [连接说明](#data-source-procedure-github)
+ [了解详情](#github-learn-more)

## 支持的功能
<a name="supported-features-github"></a>

Amazon KendraGitHub 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-github"></a>

在使用索Amazon Kendra引 GitHub 数据源之前，请在 GitHub 和AWS帐户中进行这些更改。

**在中 GitHub，请确保你有：**
+ 已创建具有 GitHub 组织管理权限的 GitHub 用户。
+ 已在 GitHub 中配置了个人访问令牌，用作您的身份验证凭证。请参阅[有关创建个人访问令牌的 GitHub 文档](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **推荐：**为身份验证凭据配置 OAuth 令牌。使用 OAuth 令牌可获得更好的 API 限制和连接器性能。参见[GitHub 有关 OAuth 授权的文档](https://docs.github.com/en/rest/apps/oauth-applications?apiVersion=2022-11-28#about-oauth-apps-and-oauth-authorizations-of-github-apps)。
+ 记下了您使用的 GitHub服务类型的 GitHub 主机 URL。例如， GitHub 云的主机 URL 可以是*https://api.github.com*， GitHub 服务器的主机 URL 可以是*https://on-prem-host-url/api/v3/*。
+ 记下您要连接 GitHub 的 GitHub企业云 (SaaS) 帐户或 GitHub 企业服务器（本地）帐户的组织名称。您可以登录到 GitHub 桌面，然后在个人资料图片下拉列表中选择 “**您的组织**”，找到您的组织名称。
+ **可选（仅限服务器）：**生成 SSL 证书并复制存储在存储Amazon S3桶中的证书的路径。 GitHub 如果您需要安全的 SSL 连接，则可以使用它进行连接。您只需使用 OpenSSL 在任何计算机上生成自签名 X509 证书。有关使用 OpenSSL 创建 X509 证书的示例，请参阅[创建并签署](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/configuring-https-ssl.html) X509 证书。
+ 添加了以下权限：

  **适用于 GitHub 企业云 (SaaS)**
  + `repo:status`— 授予对公共和私有仓库中提交状态的 read/write 访问权限。只有在向其他用户或服务授予访问私有存储库提交状态的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `repo_deployment` – 授予访问公有和私有存储库的部署状态的权限。只有在向其他用户或服务授予访问部署状态的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `public_repo` – 限制对公有存储库的访问。这包括 read/write 访问代码、提交状态、存储库项目、协作者以及公共仓库和组织的部署状态。此外还需要为公有存储库添加星标。
  + `repo:invite`— 授予在仓库上进行协作的邀请 accept/decline 的能力。只有在向其他用户或服务授予使用邀请的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `security_events` – 授权：在代码扫描 API 中读取和写入安全事件的权限。只有在向其他用户或服务授予访问安全事件的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `read:org` – 对组织成员资格、组织项目和团队成员资格的只读访问权限。
  + `user:email` – 授予对用户电子邮件地址的读取访问权限。亚马逊 Kendra 要求抓取。 ACLs
  + `user:follow` – 授予关注或取消关注其他用户的权限。亚马逊 Kendra 要求抓取。 ACLs
  + `read:user` – 授予读取用户个人资料数据的访问权限。亚马逊 Kendra 要求抓取。 ACLs
  + `workflow` – 授予添加和更新 GitHub 操作工作流文件的能力。如果同一存储库中的另一个分支上存在相同的文件（路径和内容均相同），则可以在没有此范围的情况下提交工作流文件。

  有关更多信息，请参阅 GitHub Docs 中的[ OAuth 应用范围](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/scopes-for-oauth-apps)。

  **适用于 GitHub 企业服务器（本地版）**
  + `repo:status`— 授予对公共和私有仓库中提交状态的 read/write 访问权限。只有在向其他用户或服务授予访问私有存储库提交状态的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `repo_deployment` – 授予访问公有和私有存储库的部署状态的权限。只有在向其他用户或服务授予访问部署状态的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `public_repo` – 限制对公有存储库的访问。这包括 read/write 访问代码、提交状态、存储库项目、协作者以及公共仓库和组织的部署状态。此外还需要为公有存储库添加星标。
  + `repo:invite`— 授予在仓库上进行协作的邀请 accept/decline 的能力。只有在向其他用户或服务授予使用邀请的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `security_events` – 授权：在代码扫描 API 中读取和写入安全事件的权限。只有在向其他用户或服务授予访问安全事件的权限，但不授予访问代码的权限时，才需要使用此范围。
  + `read:user` – 授予读取用户个人资料数据的访问权限。Amazon Q Business 要求抓取 ACLs。
  + `user:email` – 授予对用户电子邮件地址的读取访问权限。Amazon Q Business 要求抓取 ACLs。
  + `user:follow` – 授予关注或取消关注其他用户的权限。Amazon Q Business 要求抓取 ACLs。
  + `site_admin`— 授予站点管理员访问 GitHub 企业服务器管理 API 端点的权限。
  + `workflow` – 授予添加和更新 GitHub 操作工作流文件的能力。如果同一存储库中的另一个分支上存在相同的文件（路径和内容均相同），则可以在没有此范围的情况下提交工作流文件。

  有关更多信息，请参阅GitHub文档中[ OAuth 应用程序的作用域](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/scopes-for-oauth-apps)和[了解GitHub开发者中 OAuth 应用程序的范围](https://developer.github.com/enterprise/2.16/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/#available-scopes)。
+ 已选中每个文档在您计划用于同一索引的其他数据源中 GitHub 以及其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 GitHub 身份验证凭证存储在AWS Secrets Manager密钥中，如果使用 API，请记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 GitHub 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-github"></a>

要Amazon Kendra连接到您的 GitHub 数据源，您必须提供 GitHub 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置Amazon Kendra， GitHub 请参阅[先决条件](#prerequisites-github)。

------
#### [ Console ]

**要连接Amazon Kendra到 GitHub** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **GitHub 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **GitHub 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **GitHub来源**-在**GitHub 企业云和GitHub企业****服务器**之间进行选择。

   1. **GitHub 主机 URL** —例如， GitHub 云的主机 URL 可以是*https://api.github.com*， GitHub 服务器的主机 URL 可能是。*https://on-prem-host-url/api/v3/*

   1. **GitHub 组织名称**-输入您的 GitHub组织名称。你可以在你的 GitHub 账户中找到你的组织信息。
**注意**  
GitHub 连接器支持抓取每个数据源连接器实例的单个组织。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 GitHub 身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-GitHub-” 会自动添加到您的密钥名称中。

         1. 对于**GitHub令牌**-输入中配置的身份验证凭据值。 GitHub

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **选择存储库** – 选择对所有存储库进行爬取或选择。

      如果您选择爬取选择存储库，请为存储库添加名称，或者添加任何特定分支的名称。

   1. **内容类型** – 从文件、问题、拉取请求等选择要爬取的内容类型。

   1. **正则表达式模式** - 添加包含或排除某些文件的正则表达式模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 修改后的全新同步：每次数据源与索引同步时，仅为新增和修改过的内容编制索引。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
      + 新增、修改、删除的同步：每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。

   1. 在**同步运行计划**的**频率**中 - 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 GitHub**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-github-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `GITHUB`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **GitHubtyp** e —将类型指定为`SAAS`或`ON_PREMISE`。
+ **主机 URL**-指定 GitHub 主机 URL 或 API 端点网址。例如，如果您使用 GitHub SaaS/Enterprise Cloud，则主机 URL 可能是`https://api.github.com`，对于 GitHub 本地/企业服务器，主机 URL 可能是。`https://on-prem-host-url/api/v3/`
+ **组织名称**-指定 GitHub 账户所在组织的名称。您可以登录到 GitHub 桌面，然后在个人资料图片下拉列表中选择 “**您的组织**”，找到您的组织名称。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。 GitHub 密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "personalToken": "token"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用 GitHub 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [ GitHub S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
**注意**  
如果您使用 GitHub 服务器，则必须使用Amazon VPC才能连接到 GitHub服务器。
+  **存储库筛选条件** – 按名称和分支名称筛选存储库。
+  **文档/内容类型** – 指定是否爬取存储库文档、问题、问题评论、问题评论附件、拉取请求、拉取请求评论、拉取请求评论附件。
+  **包含和排除筛选条件** – 指定是包含还是排除某些文件和文件夹。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **访问控制列表（ACL）**- 如果您有 ACL 并想将其用于访问控制，请选择是否爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。
+  **字段映射**-选择将 GitHub 数据源字段映射到Amazon Kendra索引字段。您可以包含文档字段、提交记录、问题、问题附件、问题评论、拉取请求、拉取请求附件以及拉取请求评论。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
文档正文字段或文档正文的等效字段是 Amazon Kendra 搜索文档时所必需的。您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [GitHub 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-github-schema)。

------

## 了解详情
<a name="github-learn-more"></a>

要了解有关Amazon Kendra与 GitHub 数据源集成的更多信息，请参阅：
+ [借助连接器的强大功能，重新构想对 GitHub 存储库的Amazon KendraGitHub 搜索](https://aws.amazon.com/blogs/machine-learning/reimagine-search-on-github-repositories-with-the-power-of-the-amazon-kendra-github-connector/)

# Gmail
<a name="data-source-gmail"></a>

Gmail 是 Google 开发的电子邮件客户端，可用于发送包含文件附件的电子邮件。您可以使用文件夹和标签对 Gmail 邮件进行排序并将其存储在您的电子邮件收件箱中。您可以使用Amazon Kendra为电子邮件和邮件附件编制索引。您还可以配置Amazon Kendra为包括或排除特定的电子邮件、邮件附件和标签以进行索引。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Gmail 数据源。

要对 Amazon Kendra Gmail 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-gmail)
+ [先决条件](#prerequisites-gmail)
+ [连接说明](#data-source-procedure-gmail)
+ [了解详情](#gmail-learn-more)
+ [注意](#gmail-notes)

## 支持的功能
<a name="supported-features-gmail"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-gmail"></a>

在使用Amazon Kendra索引 Gmail 数据源之前，请在您的 Gmail 和AWS帐号中进行这些更改。

**在 Gmail 中，请确保：**
+ 已创建 Google Cloud Platform 管理员账号并创建 Google Cloud 项目。
+ 在您的管理员账户中激活了 Gmail API 和管理开发工具包 API。
+ 为您的 Gmail 创建了一个服务帐号并下载了一个 JSON 私有密钥。有关如何创建和访问私有密钥的信息，请参阅有关如何[创建服务帐号密钥](https://cloud.google.com/iam/docs/keys-create-delete#creating)和[服务帐号凭证](https://cloud.google.com/iam/docs/service-account-creds#key-types)的 Google Cloud 文档。
+ 已复制您的管理员账户电子邮件地址、服务账户电子邮件地址和用作身份验证凭证的私有密钥。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 为您的用户和要索引的共享目录添加了以下 Oauth 作用域（使用管理员角色）：
  + https://www.googleapis.com/auth/管理员目录.user.readonly
  + https://www.googleapis.com/auth/gmail.readonly
+ 在 Gmail 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Gmail 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Gmail 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-gmail"></a>

要Amazon Kendra连接到您的 Gmail 数据源，您必须提供 Gmail 凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Gmail 配置Amazon Kendra，请参阅[先决条件](#prerequisites-gmail)。

------
#### [ Console ]

**连接Amazon Kendra到 Gmail** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Gmail 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Gmail 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. 在**AWSSecrets Manager密钥****身份验证**中-选择现有密钥或创建新Secrets Manager密钥来存储您的 Gmail 身份验证凭据。如果您选择创建新密钥，则会打开一个AWSSecrets Manager秘密窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

        1. **密钥名称** - 密钥的名称。

        1. **客户端电子邮件地址** - 您从 Google 服务帐号中复制的客户端电子邮件地址。

        1. **管理员账户电子邮件地址** - 您要使用的管理员账户电子邮件地址。

        1. **私有密钥** - 您从 Google 服务帐号中复制的私有密钥。

        1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 对于**实体类型** – 选择同步邮件附件。

   1. （可选）对于**其他配置**，输入以下信息：

      1. **日期范围** - 输入日期范围以指定要爬取的电子邮件的开始和结束日期。

      1. **电子邮件域** – 使用“收件人”、“发件人”、“抄送”和“密件抄送”电子邮件域包含或排除特定电子邮件。

      1. **主题中的关键字** - 根据电子邮件主题中的关键字包含或排除电子邮件。
**注意**  
您也可以选择包含与您输入的所有主题关键字相匹配的任何文档。

      1. **标签** - 添加正则表达式模式以包含或排除某些电子邮件标签。

      1. **附件** - 添加正则表达式模式以包含或排除某些电子邮件附件。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
**重要**  
由于没有 API 可以更新永久删除的 Gmail 邮件，所以同步新增、修改或删除的内容：  
不会从您的 Amazon Kendra 索引中移除从 Gmail 中永久删除的邮件
无法同步 Gmail 电子邮件标签中的更改
要将您的 Gmail 数据来源标签更改和永久删除的电子邮件同步到您的 Amazon Kendra 索引，您必须定期进行全面爬取。

   1. 在**同步运行计划**的**频率**中 - 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。
**注意**  
Amazon Kendra由于 API 限制，Gmail 数据源连接器不支持创建自定义索引字段。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接Amazon Kendra到 Gmail**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-gmail-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `GMAIL`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
**重要**  
由于没有 API 可以更新永久删除的 Gmail 邮件，所以同步新增、修改或删除的内容：  
不会从您的 Amazon Kendra 索引中移除从 Gmail 中永久删除的邮件
无法同步 Gmail 电子邮件标签中的更改
要将您的 Gmail 数据源标签更改和永久删除的电子邮件同步到您的Amazon Kendra索引，您必须定期进行全面抓取。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Gmail 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "adminAccountEmailId": "service account email",
      "clientEmailId": "user account email",
      "privateKey": "private key"
  }
  ```
+ **IAM角色**-指定`RoleArn`何时致电`CreateDataSource`为IAM角色提供访问您的Secrets Manager密钥的权限以及致电 Gmail 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Gmail 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除筛选条件** - 指定是包含还是排除“收件人”、“发件人”、“抄送”、“密件抄送”电子邮件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **用户上下文筛选和访问控制** - 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Gmail 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
**注意**  
Amazon Kendra由于 API 限制，Gmail 数据源连接器不支持创建自定义索引字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Gmail 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-gmail-schema)。

------

## 了解详情
<a name="gmail-learn-more"></a>

要详细了解如何Amazon Kendra与 Gmail 数据源集成，请参阅：
+ [使用适用于 Amazon Kendra 的 Gmail 连接器在 Google 工作区中对电子邮件进行智能搜索](https://aws.amazon.com/blogs/machine-learning/perform-intelligent-search-across-emails-in-your-google-workspace-using-the-gmail-connector-for-amazon-kendra/).

## 注意
<a name="gmail-notes"></a>
+ 由于没有 API 可以更新永久删除的 Gmail 邮件，所以 `FULL_CRAWL`/**同步新增、修改或删除的内容**：
  + 不会从您的Amazon Kendra索引中移除从 Gmail 中永久删除的邮件
  + 无法同步 Gmail 电子邮件标签中的更改

  要将您的 Gmail 数据源标签更改和永久删除的电子邮件同步到您的Amazon Kendra索引，您必须定期进行全面抓取。
+ Amazon Kendra由于 API 限制，Gmail 数据源连接器不支持创建自定义索引字段。

# Google Drive
<a name="data-source-google-drive"></a>

Google Drive 是一项基于云的文件存储服务。您可以使用 Amazon Kendra 为存储在 Google Drive 数据来源中的共享云端硬盘、我的云端硬盘和与我共享文件夹中的文档编制索引。您可以为 Google Workspace 文档以及[文档类型](https://docs.aws.amazon.com/kendra/latest/dg/index-document-types.html)中列出的文档编制索引。您还可以使用包含和排除筛选条件按文件名、文件类型和文件路径对内容进行索引。

您可以使用[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)、API 或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Google 云端硬盘数据源。[GoogleDriveConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GoogleDriveConfiguration.html)

Amazon Kendra 有两个版本的 Google 云端硬盘连接器。每个版本支持的功能包括：

**谷歌云端硬盘连接器 V1.0/API [GoogleDriveConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GoogleDriveConfiguration.html)**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件

**谷歌云端硬盘连接器 V2.0/API [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

**注意**  
谷歌云端硬盘连接器 V1.0 /谷歌 DriveConfiguration API 于 2023 年结束。我们建议迁移到或使用 Google 云端硬盘连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra Google 云端硬盘数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [Google Drive 连接器 V1.0](data-source-v1-google-drive.md)
+ [Google Drive 连接器 V2.0](data-source-v2-google-drive.md)

# Google Drive 连接器 V1.0
<a name="data-source-v1-google-drive"></a>

Google Drive 是一项基于云的文件存储服务。您可以使用 Amazon Kendra 索引存储在 Google 云端硬盘数据源中的共享云端硬盘、“我的云端硬盘” 和 “与我共享” 文件夹中的文档和评论。您可以为 Google Workspace 文档以及[文档类型](https://docs.aws.amazon.com/kendra/latest/dg/index-document-types.html)中列出的文档编制索引。您还可以使用包含和排除筛选条件按文件名、文件类型和文件路径对内容进行索引。

**注意**  
谷歌云端硬盘连接器 V1.0 /谷歌 DriveConfiguration API 于 2023 年结束。我们建议迁移到或使用 Google 云端硬盘连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra Google 云端硬盘数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v1-google-drive)
+ [先决条件](#prerequisites-v1-google-drive)
+ [连接说明](#data-source-v1-procedure-google-drive)
+ [了解详情](#google-drive-learn-more)

## 支持的功能
<a name="supported-features-v1-google-drive"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件

## 先决条件
<a name="prerequisites-v1-google-drive"></a>

在使用 Amazon Kendra 索引 Google 云端硬盘数据源之前，请在您的 Google 云端硬盘和 AWS 帐号中进行这些更改。

**在 Google Drive 中，请确保：**
+ **要么**超级管理员角色已授予访问权限，**要么**是具有管理权限的用户。如果您已获得超级管理员角色的访问权限，则无需为自己设置超级管理员角色。
+ 使用该账号创建了一个服务帐号，并激活了**启用 G Suite 全网域授权**，并使用该帐号将 JSON 密钥作为私有密钥。
+ 已复制您的用户账户电子邮件和服务账户电子邮件。当您与您建立联系时，将您的用户帐户电子邮件作为管理员帐户电子邮件输入，在您的 AWS Secrets Manager 密钥中将服务帐户电子邮件作为客户端电子邮件输入。 Amazon Kendra 
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 在您的账户中添加了管理员 SDK API 和 Google Drive API。
+ 使用超级管理员角色向您的服务帐号添加（或要求具有超级管理员角色的用户添加）以下权限：
  + https://www.googleapis.com/auth/驱动器.readonly
  + https://www.googleapis.com/auth/驱动器.metadata.readonly
  + https://www.googleapis.com/auth/管理员目录.user.readonly
  + https://www.googleapis.com/auth/admin.directory.group.
+ 在 Google Drive 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的 AWS 账户，请确保你有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 将您的 Google Drive 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将 Google 云端硬盘数据源关联到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-v1-procedure-google-drive"></a>

 Amazon Kendra 要连接到您的 Google 云端硬盘数据源，您必须提供 Google 云端硬盘数据源的必要详细信息， Amazon Kendra 以便访问您的数据。如果您尚未配置 Google 云端硬盘， Amazon Kendra 请参阅[先决条件](#prerequisites-v1-google-drive)。

------
#### [ Console ]

**连接 Amazon Kendra 到 Google 云端硬盘** 

1. 登录 AWS 管理控制台并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**入门**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Google Drive 连接器 V1.0**，然后选择**添加连接器**。

1. 在**指定数据来源详细信息**页面上输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 对于**身份验证类型** - 选择**现有**和**新建**。如果您选择使用现有密钥，请使用**选择密钥**来选择您的密钥。

   1. 如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥选项。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

        1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Google 云端硬盘” 会自动添加到您的密钥名称中。

        1. 对于**管理员账户电子邮件地址**、**客户端电子邮件地址**和**私有密钥**，请输入您生成并从 Google Drive 账户下载的身份验证凭证值。

        1. 选择**保存身份验证**。

   1. **IAM 角色**-选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **排除用户账户** - 您要从索引中排除的 Google Drive 用户。您最多可以添加 100 个用户账户。

   1. **排除共享云端硬盘** - 要从索引中排除的 Google Drive 共享云端硬盘。您最多可以添加 100 个共享驱动器。

   1. **排除文件类型驱动器** - 要从索引中排除的 Google Drive 文件类型。您也可以选择编辑 MIME 类型选择。

   1. **对于其他配置** - 添加正则表达式模式以包含或排除某些内容。最多可以添加 100 个模式。

   1. **频率** - Amazon Kendra 与您的数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 对于**GoogleDrive 字段名称****和其他建议的字段映射**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接 Amazon Kendra 到 Google 云端硬盘**

您必须使用 [GoogleDriveConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GoogleDriveConfiguration.html)API 指定以下内容：
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Google 云端硬盘账户身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "clientAccount": "service account email",
      "adminAccount": "user account email"",
      "privateKey": "private key"
  }
  ```
+ **IAM 角色**-指定`RoleArn`何时致电`CreateDataSource`为 IAM 角色提供访问您的 Secrets Manager 密钥的权限，以及致电 APIs 所需的公众以获取 Google 云端硬盘连接器和 Amazon Kendra。有关更多信息，请参阅 [Google Drive 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **包含和排除筛选条件** - 默认情况下， Amazon Kendra 会为 Google Drive 中的所有文档编制索引。您可以指定是包含还是排除共享云端硬盘、用户账户、文档 MIME 类型和文件中的某些内容。如果您选择排除用户账户，则该账户拥有的 “我的云端硬盘” 中的所有文件都不会被编入索引。除非文件的所有者也被排除在外，否则将对与用户共享的文件编制索引。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **字段映射** - 选择将 Google Drive 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。

------

## 了解详情
<a name="google-drive-learn-more"></a>

要详细了解如何 Amazon Kendra 与 Google 云端硬盘数据源集成，请参阅：
+ [开始使用 Amazon Kendra Google 云端硬盘连接器](https://aws.amazon.com/blogs/machine-learning/getting-started-with-the-amazon-kendra-google-drive-connector/)

# Google Drive 连接器 V2.0
<a name="data-source-v2-google-drive"></a>

Google Drive 是一项基于云的文件存储服务。您可以使用 Amazon Kendra 索引存储在 Google 云端硬盘数据源中的共享云端硬盘、“我的云端硬盘” 和 “与我共享” 文件夹中的文档和评论。您可以为 Google Workspace 文档以及[文档类型](https://docs.aws.amazon.com/kendra/latest/dg/index-document-types.html)中列出的文档编制索引。您还可以使用包含和排除筛选条件按文件名、文件类型和文件路径对内容进行索引。

**注意**  
谷歌云端硬盘连接器 V1.0 /谷歌 DriveConfiguration API 于 2023 年结束。我们建议迁移到或使用 Google 云端硬盘连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra Google 云端硬盘数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v2-google-drive)
+ [先决条件](#prerequisites-v2-google-drive)
+ [连接说明](#data-source-procedure-v2-google-drive)
+ [注意](#google-drive-notes)

## 支持的功能
<a name="supported-features-v2-google-drive"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v2-google-drive"></a>

在使用 Amazon Kendra 索引 Google 云端硬盘数据源之前，请在您的 Google 云端硬盘和 AWS 帐号中进行这些更改。

**在 Google Drive 中，请确保：**
+ **要么**超级管理员角色已授予访问权限，**要么**是具有管理权限的用户。如果您已获得超级管理员角色的访问权限，则无需为自己设置超级管理员角色。
+ 已配置 Google Drive 服务帐号连接凭证，其中包含您的管理员帐号电子邮件、客户电子邮件（服务帐号电子邮件）和私有密钥。请参阅[有关创建和删除服务帐号密钥的 Google Cloud 文档](https://cloud.google.com/iam/docs/keys-create-delete)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 创建了一个 Google Cloud 服务帐号（具有使用用户身份授权的帐号），并激活了 “**启用 G Suite 全网域授**权” 进行 server-to-server身份验证，然后使用该帐号生成了 JSON 私钥。
**注意**  
私有密钥应在创建服务帐号之后生成。
+ 在您的用户账户中添加了管理员 SDK API 和 Google Drive API。
+ **可选：**已配置包含客户端 ID、客户端密钥和刷新令牌的 Google Drive OAuth 2.0 连接凭据作为特定用户的连接凭据。您需要它来爬取个人账户数据。请参阅 [Google 文档，了解如何使用 OAuth 2.0 进行访问 APIs](https://developers.google.com/identity/protocols/oauth2)。
+ 使用超级管理员角色向您的服务帐号添加（或要求具有超级管理员角色的用户添加）以下 OAuth范围。要爬取 Google Workspace 网域中所有用户的所有文档和访问控制（ACL）信息，需要这些 API 范围：
  + https://www.googleapis.com/auth/云端硬盘.readonly — 查看和下载所有的 Google 云端硬盘文件
  + https://www.googleapis.com/auth/云端硬盘.metadata.readonly — 查看 Google 云端硬盘中文件的元数据
  + https://www.googleapis.com/auth/admin.directory.group.readonly — 仅用于检索群组、群组别名和成员信息的范围。这是 Amazon Kendra 身份搜寻器所必需的。
  + https://www.googleapis.com/auth/admin.directory.user.readonly — 仅用于检索用户或用户别名的范围。这是在 Ident Amazon Kendra ity Crawler 中列出用户和进行设置 ACLs所必需的。
  + https://www.googleapis.com/auth/云平台-用于生成访问令牌以获取大型 Google 云端硬盘文件内容的范围。
  + https://www.googleapis.com/auth/forms.body.readonly — 从谷歌表单中获取数据的范围。

  **要支持 Forms API，请添加以下附加范围：**
  + https://www.googleapis.com/auth/表单.body.readonly
+ 在 Google Drive 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的 AWS 账户，请确保你有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 将您的 Google Drive 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将 Google 云端硬盘数据源关联到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v2-google-drive"></a>

 Amazon Kendra 要连接到您的 Google 云端硬盘数据源，您必须提供 Google 云端硬盘数据源的必要详细信息， Amazon Kendra 以便访问您的数据。如果您尚未配置 Google 云端硬盘， Amazon Kendra 请参阅[先决条件](#prerequisites-v2-google-drive)。

------
#### [ Console ]

**连接 Amazon Kendra 到 Google 云端硬盘** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Google Drive 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Google 云端硬盘连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证**-根据您的用例在 **Google 服务帐号**和 **OAuth 2.0 身份验证**之间进行选择。

   1. AWS Secrets Manager s@@ **ecret** —选择现有密钥，或创建一个新 Secrets Manager 密钥来存储您的 Google 云端硬盘身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 如果您选择 **Google 服务账户**，请输入您的密钥名称、服务账户配置中的管理员用户或“服务账户用户”的电子邮件 ID（管理员电子邮件）、服务账户的电子邮件 ID（客户端电子邮件）以及您在服务账户中创建的私有密钥。

         保存并添加您的密钥

      1. 如果您选择 **OAuth 2.0 身份验证**，请输入您在 OAuth 账户中创建的密钥名称、客户端 ID、客户端密钥和刷新令牌。用户邮件 ID（配置了连接详细信息的用户）将被设置为 ACL。由于 API 限制，连接器不会将其他 user/group 主体信息设置为 ACL。

         保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. （仅适用于 Google 服务账户身份验证用户）

      **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM 角色**-选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **同步内容** - 选择要爬取的选项或内容。您可以选择爬取“我的云端硬盘”（个人文件夹）和/或“共享云端硬盘”（与您共享的文件夹）。您也可以添加文件注释。

   1. 在**其他配置 - 可选**中，您也输入以下可选信息：

      1. **最大文件大小**-设置要抓取的文件的最大大小限制。 MBs 

      1. **用户电子邮件地址** - 添加要包含或排除的用户电子邮件地址。

      1. **共享云端硬盘** - 添加要包含或排除的共享云端硬盘名称。

      1. **MIME 类型** - 添加要包含或排除的 MIME 类型。

      1. **实体正则表达式模式** - 添加正则表达式模式以包含或排除所有受支持实体的某些附件。最多可以添加 100 个模式。

         您可以为**文件名、文件类型和**文件**路径****配置正则 include/exclude **表达式模式。
         + **文件名** - 要包含或排除的文件的名称。例如，要为名称为 `teamroster.txt` 的文件编制索引，请提供 `teamroster`。
         + **文件类型** - 要包含或排除的文件的类型。例如，.pdf、.txt、.docx。
         + **文件路径** - 要包含或排除的文件的路径。例如，要仅为云端硬盘的 `Products list` 文件夹内的文件编制索引，请提供 `/Products list`。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 修改过的新同步：每次数据源与索引同步时，仅为新增和修改过的内容编制索引。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
      + 新增、修改、删除的同步：每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。 Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
**重要**  
Google Drive API 不支持从永久删除的文件中检索评论。可以检索已丢弃文件中的评论。当文件被丢弃时，连接器将从 Amazon Kendra 索引中删除注释。

   1. 在**同步运行计划**的**频率**中 - 选择同步数据来源内容并更新索引的频率。

   1. 在 “**同步运行历史记录**” 中，选择在同步数据源 Amazon S3 时将自动生成的报告存储在中。这对于在同步数据来源时跟踪问题很有用。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 对于**文件**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。
**注意**  
Google Drive API 不支持创建自定义字段。自定义字段映射不适用于 Google Drive 连接器。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接 Amazon Kendra 到 Google 云端硬盘**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `GOOGLEDRIVEV2`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **身份验证类型**-指定是使用服务帐户身份验证还是 OAuth 2.0 身份验证。
+ **同步模式**-指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。首次与同步数据源时， Amazon Kendra 默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`每次数据源与索引同步时，仅对新的、修改过的和已删除的内容编制索引。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
  + `CHANGE_LOG`每次数据源与索引同步时，仅索引新的和修改过的内容。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
**重要**  
Google Drive API 不支持从永久删除的文件中检索评论。可以检索已丢弃文件中的评论。当文件被丢弃时，连接器将从 Amazon Kendra 索引中删除注释。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在 Google 云端硬盘账户中创建的身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。如果您使用 Google 服务账户身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "clientEmail": "user account email",
      "adminAccountEmail": "service account email",
      "privateKey": "private key"
  }
  ```

  如果您使用 OAuth 2.0 身份验证，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "clientID": "OAuth client ID",
      "clientSecret": "client secret",
      "refreshToken": "refresh token"
  }
  ```
+ **IAM 角色**-指定`RoleArn`何时致电`CreateDataSource`为 IAM 角色提供访问您的 Secrets Manager 密钥的权限，以及致电 APIs 所需的公众以获取 Google 云端硬盘连接器和 Amazon Kendra。有关更多信息，请参阅 [Google Drive 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **我的云端硬盘、共享云端硬盘、评论** - 您可以指定是否爬取这些类型的内容。
+  **包含和排除筛选条件** - 您可以指定是包含还是排除某些用户账户、共享云端硬盘和 MIME 类型。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **访问控制列表（ACL）**- 如果您有 ACL 并想将其用于访问控制，请选择是否爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Google Drive 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Google Drive 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-google-drive-schema)。

------

## 注意
<a name="google-drive-notes"></a>
+ 由于 Google Drive UI 不支持创建自定义字段，因此自定义字段映射不适用于 Google Drive 连接器。
+ Google Drive API 不支持从永久删除的文件中检索评论。但是，对于已丢弃的文件，可以检索评论。当文件被丢弃时， Amazon Kendra 连接器将从 Amazon Kendra 索引中删除注释。
+ Google Drive API 不会返回 .docx 文件中存在的评论。
+ 如果将特定 Google document（文档、电子表格、幻灯片等）的权限设置为**一般访问权限：拥有链接的任何人**或**共享到您的特定公司域**，则在进行查询的用户访问该文档之前，Amazon Kendra 搜索用户将无法看到该文档。

# IBM DB2
<a name="data-source-ibm-db2"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 IBM DB2 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

IBM DB2 是 IBM 开发的一个关系数据库管理系统。如果您是 IBM DB2 用户，则可以使用 Amazon Kendra 为您的 IBM DB2 数据来源编制索引。Amazon KendraIBM DB2数据源连接器支持 DB2 11.5.7。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的IBM DB2数据源。

要对Amazon KendraIBM DB2数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-ibm-db2)
+ [先决条件](#prerequisites-ibm-db2)
+ [连接说明](#data-source-procedure-ibm-db2)
+ [注意](#ibm-db2-notes)

## 支持的功能
<a name="supported-features-ibm-db2"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-ibm-db2"></a>

在使用索Amazon Kendra引IBM DB2数据源之前，请在IBM DB2和AWS帐户中进行这些更改。

**在 IBM DB2 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 在 IBM DB2 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 IBM DB2 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将IBM DB2数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-ibm-db2"></a>

要Amazon Kendra连接到您的IBM DB2数据源，您必须提供IBM DB2凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，IBM DB2请参Amazon Kendra阅[先决条件](#prerequisites-ibm-db2)。

------
#### [ Console ]

**要连接Amazon Kendra到 IBM DB2** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **IBM DB2 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **IBM DB2 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** - 输入数据库主机名。

   1.  **端口** - 输入数据库端口。

   1.  **实例** - 输入数据库实例。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的IBM DB2身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-IBM DB2-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + **用户 IDs列**-输入包含允许用户访问内容 IDs 的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（“文档” IDs、“**文档****标题**” 和 “**来源**” URLs）中进行选择，以映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 IBM DB2**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `db2`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。IBM DB2密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用IBM DB2连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [IBM DB2 S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 IBM DB2 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[IBM DB2 模板架构](ds-schemas.md#ds-ibm-db2-schema)。

------

## 注意
<a name="ibm-db2-notes"></a>
+ 在Amazon Kendra检查更新内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Jira
<a name="data-source-jira"></a>

Jira 是一款用于软件开发、产品管理和错误跟踪的项目管理工具。您可以使用Amazon Kendra索引 Jira 项目、议题、评论、附件、工作日志和状态。

Amazon Kendra目前仅支持 Jira Cloud。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)或 [JiraConfiguration ](https://docs.aws.amazon.com/kendra/latest/APIReference/API_JiraConfiguration.html)API Amazon Kendra 连接到您的 Jira 数据源。有关每个版本支持的功能列表，请参阅[支持的功能](#supported-features-jira)。

要对 Amazon Kendra Jira 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-jira)
+ [先决条件](#prerequisites-jira)
+ [连接说明](#data-source-procedure-jira)
+ [了解详情](#jira-learn-more)

## 支持的功能
<a name="supported-features-jira"></a>

Amazon KendraJira 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-jira"></a>

在使用Amazon Kendra索引 Jira 数据源之前，请在您的 Jira 和AWS账户中进行这些更改。

**在 Jira 中，请确保：**
+ 已配置的 API 令牌身份验证凭证，包括 Jira ID（用户名或电子邮件）和 Jira 凭证（Jira API 令牌）。请参阅[有关管理 API 令牌的 Atlassian 文档](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 已记下您的 Jira 账户设置中的 Jira 账户 URL。例如 *https://company.atlassian.net/*。
+ 在 Jira 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Jira 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Jira 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-jira"></a>

要Amazon Kendra连接到您的 Jira 数据源，您必须提供 Jira 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Jira 配置Amazon Kendra，请参阅[先决条件](#prerequisites-jira)。

------
#### [ Console ]

**连接Amazon Kendra到 Jira** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Jira 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Jira 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Jira 账户 URL** – 输入您的 Jira 账户 URL。例如：*https://company.atlassian.net/*。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 Jira 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Jira-” 会自动添加到您的密钥名称中。

         1. 对于 **Jira ID** - 输入 Jira 用户名或电子邮件地址。

         1. 对于**密码/令牌** – 输入在 Jira 中配置的 Jira API 令牌。

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **选择要编制索引的 Jira 项目** – 选择爬取所有项目或特定项目。

   1. **其他配置** – 指定特定状态和问题类型。选择爬取评论、附件和工作日志。使用正则表达式模式来包含或排除特定的内容。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接Amazon Kendra到 Jira**

您必须使用 [JiraConfiguration ](https://docs.aws.amazon.com/kendra/latest/APIReference/API_JiraConfiguration.html)API 指定以下内容：
+ **数据来源 URL** - 指定您的 Jira 账户 URL。例如 *company.atlassian.net*。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Jira 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "jiraId": "Jira user name or email",
      "jiraCredential": "Jira API token"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`为IAM角色提供访问您的Secrets Manager密钥的权限以及调用 Jira 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Jira 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **虚拟私有云（VPC）**- 在数据来源配置中指定 `VpcConfiguration`。请参阅[配置 Amazon Kendra 以使用 VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。
+  **更改日志** – Amazon Kendra 是否应使用 Jira 数据来源的更改日志机制来判断索引中的文档是否需要更新。
**注意**  
如果您不想让 Amazon Kendra 扫描所有文档，请使用更改日志。如果您的更改日志很大，则扫描 Jira 数据源中的文档所需的时间可能比处理更改日志所需的时间Amazon Kendra少。如果您是首次将 Jira 数据来源与索引同步，则会扫描所有文档。
+  **包含和排除筛选条件** – 您可以指定是包含还是排除特定文件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **评论、附件和工作日志** – 您可以指定是否爬取问题的某些评论、附件和工作日志。
+ **项目、问题、状态**-您可以指定是否对某些项目 IDs、问题类型和状态进行爬网。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Jira 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

------

## 了解详情
<a name="jira-learn-more"></a>

要了解有关Amazon Kendra与 Jira 数据源集成的更多信息，请参阅：
+ [使用 Jira 云连接器智能搜索你的 Amazon Kendra Jira 项目](https://aws.amazon.com/blogs/machine-learning/intelligently-search-your-jira-projects-with-amazon-kendra-jira-cloud-connector/)

# Microsoft Exchange
<a name="data-source-exchange"></a>

Microsoft Exchange 是一款用于消息、会议和文件共享的企业协作工具。如果你是微软 Exchange 用户，你可以使用Amazon Kendra索引你的微软 Exchange 数据源。

你可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到你的 Microsoft Exchange 数据源。

有关Amazon Kendra微软 Exchange 数据源连接器的疑难解答，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

## 支持的功能
<a name="supported-features-exchange"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-exchange"></a>

在使用Amazon Kendra索引微软 Exchange 数据源之前，请在微软 Exchange 和AWS账户中进行这些更改。

**在 Microsoft Exchange 中，请确保：**
+ 在 Office 365 中创建了一个 Microsoft Exchange 账户。
+ 记下了您的 Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth应用程序中找到你的租户 ID。
+ 在 Azure 门户中配置了 OAuth 应用程序，并记下了客户端 ID 和客户端密钥或客户端凭据。有关更多信息，请参阅 [Microsoft 教程](https://learn.microsoft.com/en-us/power-apps/developer/data-platform/walkthrough-register-app-azure-active-directory)和[注册应用程序示例](https://learn.microsoft.com/en-us/azure/healthcare-apis/register-application)。
**注意**  
当您在 Azure 门户中创建或注册应用程序时，密钥 ID 代表实际的密钥值。在创建密钥和应用程序时，您必须立即记下或保存该实际的密钥值。您可以通过在 Azure 门户中选择应用程序名称，然后导航到有关证书和密钥的菜单选项来访问您的密钥。  
您可以通过在 Azure 门户中选择应用程序名称，然后导航到概述页面来访问您的客户端 ID。其中的“应用程序（客户端）ID”即是客户端 ID。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 为连接器应用程序添加了以下权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-exchange.html)
+ 在 Microsoft Exchange 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Microsoft Exchange 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果你没有现有的IAM角色或密钥，则可以在将 Microsoft Exchange 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-exchange"></a>

Amazon Kendra要连接到你的 Microsoft Exchange 数据源，你必须提供微软 Exchange 数据源的必要细节，这样Amazon Kendra才能访问你的数据。如果你尚未为 Microsoft Exchange 进行配置Amazon Kendra，请参阅[先决条件](#prerequisites-exchange)。

------
#### [ Console ]

**Amazon Kendra连接到微软 Exchange** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Microsoft Exchange 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Microsoft Exchange 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **租户 ID** - 输入您的 Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **AWS Secrets Manager密钥** — 选择现有密钥或创建新Secrets Manager密钥来存储你的 Microsoft Exchange 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 'AmazonKendra-微软 Exchange

         1. 对于**客户端 ID** 和**客户端密钥** - 在 Azure 门户中输入在 Microsoft Exchange 中配置的身份验证凭证。

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **用户 IDs**-如果您想按某些电子邮件筛选内容，请提供用户电子邮件。

   1. **其他配置** - 输入要爬取的内容类型。
      + **实体类型**-您可以选择抓取日历或联系 OneNotes人内容。
      + **日历爬取** - 输入开始日期和结束日期，以爬取特定日期范围内的内容。
      + **包括电子邮件** - 输入 “收件人”、“发件人”和电子邮件主题行以筛选要爬取的某些电子邮件。
      + **共享文件夹访问** - 选择启用对访问控制列表的爬取，以实现对 Microsoft Exchange 数据来源的访问控制。
      + **域名正则表达式** - 添加正则表达式模式，以包含或排除特定的电子邮件域名。
      + **正则表达式模式** - 添加包含或排除某些文件的正则表达式模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。
**注意**  
Amazon Kendra微软 Exchange 数据源连接器不支持自定义字段映射。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**Amazon Kendra连接到微软 Exchange**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-msexchange-schema.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `MSEXCHANGE`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **租户 ID**-你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含微软 Exchange 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "clientId": "client ID",
      "clientSecret": "client secret"
  }
  ```
+ **IAM角色** —指定`RoleArn`何时调用为IAM角色提供`CreateDataSource`访问您的Secrets Manager密钥的权限，以及调用 Microsoft Exchange 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Microsoft Exchange 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **包含和排除筛选条件** - 指定是包含还是排除某些内容。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **访问控制列表（ACL）**- 如果您有 ACL 并想将其用于访问控制，请选择是否爬取文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。
+  **字段映射** - 选择将 Microsoft Exchange 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Microsoft Exchange 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-msexchange-schema)。

------

## 了解详情
<a name="exchange-learn-more"></a>

要了解有关Amazon Kendra与你的 Microsoft Exchange 数据源集成的更多信息，请参阅：
+ [使用适用于 Amazon Kendra 的 Exchange 连接器为 Microsoft Exchange 内容编制索引](https://aws.amazon.com/blogs/machine-learning/index-your-microsoft-exchange-content-using-the-exchange-connector-for-amazon-kendra/)

## 注意
<a name="exchange-notes"></a>
+ 启用访问控制列表 (ACLs) 后，由于 Microsoft Exchange API 的限制，“仅同步新内容或修改过的内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。

# 微软 OneDrive
<a name="data-source-onedrive"></a>

Microsoft OneDrive 是一项基于云的存储服务，你可以用它来存储、共享和托管你的内容。您可以使用索 Amazon Kendra 引您的 OneDrive 数据源。

您可以使用[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)和 [OneDriveConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_OneDriveConfiguration.html)API Amazon Kendra 连接到您的 OneDrive 数据源。

Amazon Kendra 有两个版本的 OneDrive 连接器。每个版本支持的功能包括：

**微软 OneDrive 连接器 V1.0/API [OneDriveConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_OneDriveConfiguration.html)**
+ 字段映射
+ 包含/排除筛选条件

**微软 OneDrive 连接器 V2.0/API [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)**
+ 用户上下文筛选
+ 用户身份爬网程序
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

**注意**  
对 OneDrive 连接器 V1.0/ OneDriveConfiguration API 的支持计划于 2023 年 6 月结束。我们建议使用 OneDrive 连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra OneDrive 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [微软 OneDrive 连接器 V1.0](data-source-v1-onedrive.md)
+ [微软 OneDrive 连接器 V2.0](data-source-v2-onedrive.md)
+ [了解详情](#onedrive-learn-more)
+ [注意](#onedrive-notes)

# 微软 OneDrive 连接器 V1.0
<a name="data-source-v1-onedrive"></a>

Microsoft OneDrive 是一项基于云的存储服务，你可以用它来存储、共享和托管你的内容。你可以使用索引你 Amazon Kendra 的 Microsoft OneDrive 数据源。

**注意**  
对 OneDrive 连接器 V1.0/Microsft OneDrive API 的支持计划于 2023 年 6 月结束。我们建议使用 OneDrive 连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra OneDrive 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v1-onedrive)
+ [先决条件](#prerequisites-v1-onedrive)
+ [连接说明](#data-source-v1-procedure-onedrive)

## 支持的功能
<a name="supported-features-v1-onedrive"></a>
+ 字段映射
+ 包含/排除筛选条件

## 先决条件
<a name="prerequisites-v1-onedrive"></a>

在使用索 Amazon Kendra 引 OneDrive 数据源之前，请在 OneDrive 和 AWS 帐户中进行这些更改。

**在 Azure Active Directory（AD）中，请确保：**
+ 已创建 Azure Active Directory（AD）应用程序
+ 使用 AD 应用程序 ID 在 AD 站点上注册应用程序的密钥。该密钥必须包含应用程序 ID 和密钥。
+ 已复制组织的 AD 域。
+ 在 Microsoft Graph 选项上为您的 AD 应用程序添加了以下应用程序权限：
  + 读取所有网站集中的文件（File.Read.All）
  + 阅读所有用户的完整个人资料（User.Read.All）
  + 读取目录数据（Directory.Read.All）
  + 阅读所有组（Group.Read.All）
  + 阅读所有网站集中的项目（Site.Read.All）
+ 复制必须为其文档编制索引的用户列表。您可以选择提供用户名列表，也可以在存储在 Amazon S3中的文件中提供用户名。创建数据来源后，您可以：
  + 修改用户列表。
  + 从用户列表更改为存储在存储 Amazon S3 桶中的列表。
  + 更改用户列表的 Amazon S3 存储桶位置。如果您更改存储桶位置，则还必须更新数据源的 IAM 角色，使其能够访问存储桶。
**注意**  
如果您将用户名列表存储在 Amazon S3 存储桶中，则数据源的 IAM 策略必须提供对存储桶的访问权限以及对存储桶加密时使用的密钥（如果有）的访问权限。
+ 已选中每个文档在您计划用于同一索引的其他数据源中 OneDrive 以及其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的 AWS 账户，请确保你有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 将您的 OneDrive 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将 OneDrive 数据源连接到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-v1-procedure-onedrive"></a>

要 Amazon Kendra 连接到您的 OneDrive 数据源，您必须提供 OneDrive 凭据的详细信息， Amazon Kendra 以便访问您的数据。如果您尚未进行配置， OneDrive 请参 Amazon Kendra 阅[先决条件](#prerequisites-v1-onedrive)。

------
#### [ Console ]

**要连接 Amazon Kendra 到 OneDrive** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **OneDrive 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **OneDrive 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **OneDrive 租户 ID**-输入不带协议的 OneDrive 租户 ID。

   1. **身份验证类型** - 选择**新建**或**现有**。

   1. 

      1. 如果您选择**现有**，请为**选择密钥**选择现有密钥。

      1. 如果您选择**新建**，请在**新的 AWS Secrets Manager 密钥**部分中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-OneDrive-” 会自动添加到您的密钥名称中。

         1. 对于**应用程序 ID** 和**应用程序密码**-输入您 OneDrive 帐户中的身份验证凭据值，然后选择**保存**身份验证。

   1. **IAM 角色**-选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 根据您的使用案例，选择**列表文件**和**名称列表**。

      1. 如果选择**列表文件**，请输入以下信息：

         1.  **选择位置** - 输入 Amazon S3 存储桶的路径。

            **将用户列表文件添加到 Amazon S3**-选择将您的用户列表文件添加到您的 Amazon S3 存储桶。

            **用户本地组映射** - 选择使用本地组映射来筛选您的内容。

      1. 如果选择**名称列表**，请输入以下信息：

         1.  **用户名** - 输入最多 10 个要索引的用户驱动器。要添加 10 个以上的用户，请创建一个包含用户名的文件。

            **添加另一个** - 选择添加更多用户。

            **用户本地组映射** - 选择使用本地组映射来筛选您的内容。

   1. 对于**其他配置** - 添加正则表达式模式以包含或排除某些文件。最多可以添加 100 个模式。

   1. 在 “**同步运行计划**” 中，“**频率**”-选择与数据源同步的频率。 Amazon Kendra 

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 对于**默认数据源字段****和其他建议的字段映射**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接 Amazon Kendra 到 OneDrive**

您必须使用 [OneDriveConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_OneDriveConfiguration.html)API 指定以下内容：
+ **租户 ID** - 指定组织的 Azure Active Directory 域。
+ **OneDrive 用户**-指定应为其文档编制索引的用户帐户列表。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您账户身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。 OneDrive 密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "username": "OAuth client ID",
      "password": "client secret"
  }
  ```
+ **IAM ro** le —指定`RoleArn`何时调用`CreateDataSource`以向 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及调用 OneDrive 连接器 APIs 所需的公众的权限，以及 Amazon Kendra。有关更多信息，请参阅 [ OneDrive S3 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **包含和排除筛选条件** - 指定是包含还是排除文档。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **字段映射** - 选择将 OneDrive 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。

------

# 微软 OneDrive 连接器 V2.0
<a name="data-source-v2-onedrive"></a>

Microsoft OneDrive 是一项基于云的存储服务，你可以用它来存储、共享和托管你的内容。您可以使用索 Amazon Kendra 引您的 OneDrive数据源。

您可以使用[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)和 [OneDriveConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/OneDriveConfiguration.html)API Amazon Kendra 连接到您的 OneDrive 数据源。



**注意**  
对 Conn OneDrive ector V1.0/ OneDriveConfiguration API 的支持计划于 2023 年 6 月结束。我们建议使用 OneDrive 连接器 V2.0/ TemplateConfiguration API。2.0 版提供了额外的 ACLs 身份搜寻器功能。

要对 Amazon Kendra OneDrive 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v2-onedrive)
+ [先决条件](#prerequisites-v2-onedrive)
+ [连接说明](#data-source-procedure-v2-onedrive)

## 支持的功能
<a name="supported-features-v2-onedrive"></a>

Amazon Kendra OneDrive 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v2-onedrive"></a>

在使用索 Amazon Kendra 引 OneDrive 数据源之前，请在 OneDrive 和 AWS 帐户中进行这些更改。

**在中 OneDrive，请确保你有：**
+ 已在 Office 365 中创建了一个 OneDrive 账户。
+ 记下了您的 Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。
+ 在 Azure 门户中创建了一个 OAuth 应用程序，并记下了用于使用密钥进行身份验证的客户端 ID 和客户端 AWS Secrets Manager 密钥或客户端凭据。有关更多信息，请参阅 [Microsoft 教程](https://learn.microsoft.com/en-us/power-apps/developer/data-platform/walkthrough-register-app-azure-active-directory)和[注册应用程序示例](https://learn.microsoft.com/en-us/azure/healthcare-apis/register-application)。
**注意**  
当您在 Azure 门户中创建或注册应用程序时，密钥 ID 代表实际的密钥值。在创建密钥和应用程序时，您必须立即记下或保存该实际的密钥值。您可以通过在 Azure 门户中选择应用程序名称，然后导航到有关证书和密钥的菜单选项来访问您的密钥。  
您可以通过在 Azure 门户中选择应用程序名称，然后导航到概述页面来访问您的客户端 ID。其中的“应用程序（客户端）ID”即是客户端 ID。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 使用 AD 应用程序 ID 在 AD 站点上注册应用程序的密钥。该密钥必须包含应用程序 ID 和密钥。
+ 已复制组织的 AD 域。
+ 在 Microsoft Graph 选项上为您的 AD 应用程序添加了以下权限：
  + 读取所有网站集中的文件（File.Read.All）
  + 读取所有用户的完整个人资料（User.Read.All）
  + 阅读所有组（Group.Read.All）
  + 读取所有笔记（Notes.Read.All）
+ 复制必须为其文档编制索引的用户列表。您可以选择提供用户名列表，也可以在存储在 Amazon S3中的文件中提供用户名。创建数据来源后，您可以：
  + 修改用户列表。
  + 从用户列表更改为存储在存储 Amazon S3 桶中的列表。
  + 更改用户列表的 Amazon S3 存储桶位置。如果您更改存储桶位置，则还必须更新数据源的 IAM 角色，使其能够访问存储桶。
**注意**  
如果您将用户名列表存储在 Amazon S3 存储桶中，则数据源的 IAM 策略必须提供对存储桶的访问权限以及对存储桶加密时使用的密钥（如果有）的访问权限。  
 OneDrive 连接器使用 O **nedrive** 用户属性中显示的 “**来自联系人信息的电子邮件**”。确保您要爬取其数据的用户在**联系信息**页面中配置了电子邮件字段，因为对于新用户，该字段可能为空。

**在您的 AWS 账户中，请确保您有：**
+ 已创建 Amazon Kendra 索引，如果使用 API，则记下索引 ID。
+ 为您的数据源创建了一个 IAM 角色，如果使用 API，请记下该角色的 ARN。 IAM 
+ 将您的 OneDrive 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下该密钥的 ARN。

如果您没有现有的 IAM 角色或密钥，则可以在将 OneDrive 数据源连接到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v2-onedrive"></a>

要 Amazon Kendra 连接到您的 OneDrive 数据源，您必须提供 OneDrive 凭据的详细信息， Amazon Kendra 以便访问您的数据。如果您尚未进行配置 Amazon Kendra， OneDrive 请参阅[先决条件](#prerequisites-v2-onedrive)。

------
#### [ Console ]

**要连接 Amazon Kendra 到 OneDrive** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **OneDrive 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **OneDrive 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **OneDrive 租户 ID**-输入不带协议的 OneDrive 租户 ID。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. 在**身份验证** 中 - 选择**新建**或**现有**。

   1. 

      1. 如果您选择**现有**，请为**选择密钥**选择现有密钥。

      1. 如果您选择**新建**，请在**新的 AWS Secrets Manager 密钥**部分中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-OneDrive-” 会自动添加到您的密钥名称中。

         1. 对于**客户端 ID** 和**客户端密钥** - 输入客户端 ID 和客户端密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM 角色**-选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

1. 

   1. 对于**同步范围**-选择要为哪些用户 OneDrive 的数据编制索引。您可以手动添加最多 10 个用户。

   1. 对于**其他配置** - 添加正则表达式模式以包含或排除某些内容。最多可以添加 100 个模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时， Amazon Kendra 默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。 Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接 Amazon Kendra 到 OneDrive**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-onedrive-schema)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `ONEDRIVEV2`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **租户 ID** - 指定 Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。
+ **同步模式**-指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。 Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。 Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。 OneDrive 

  如果您使用 OAuth 2.0 身份验证，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "clientId": "client ID",
      "clientSecret": "client secret"
  }
  ```
+ **IAM ro** le —指定`RoleArn`何时调用`CreateDataSource`以向 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及调用 OneDrive 连接器 APIs 所需的公众的权限，以及 Amazon Kendra。有关更多信息，请参阅 [ OneDrive S3 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除筛选器**-您可以指定是包含还是排除某些文件、 OneNote 章节和 OneNote 页面。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射**-只能映射连接器的内置或常用索引字段。 Amazon Kendra OneDrive 由于 API 限制，自定义字段映射不适用于 OneDrive 连接器。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。

有关要配置的其他重要 JSON 键的列表，请参阅 [OneDrive 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-onedrive-schema)。

------

## 了解详情
<a name="onedrive-learn-more"></a>

要了解有关 Amazon Kendra 与 OneDrive 数据源集成的更多信息，请参阅：
+ [宣布推出更新的 Microsoft OneDrive 连接器 (V2)。 Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/announcing-the-updated-microsoft-onedrive-connector-v2-for-amazon-kendra/)

## 注意
<a name="onedrive-notes"></a>
+ 启用访问控制列表 (ACLs) 后，由于 OneDrive API 限制，“仅同步新内容或修改内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。

# 微软 SharePoint
<a name="data-source-sharepoint"></a>

SharePoint 是一项协作建站服务，可用于自定义 Web 内容以及创建页面、网站、文档库和列表。您可以使用索 Amazon Kendra 引您的 SharePoint 数据源。

Amazon Kendra 目前支持 SharePoint 在线版和 SharePoint服务器版（版本 2013、2016、2019 和订阅版）。

您可以使用[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)、API 或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API 连接到 Amazon Kendra 您的 SharePoint 数据源。[SharePointConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SharePointConfiguration.html)

Amazon Kendra 有两个版本的 SharePoint 连接器。每个版本支持的功能包括：

**SharePoint 连接器 V1.0/API [SharePointConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SharePointConfiguration.html)**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 更改日志
+ 虚拟私有云（VPC）

**SharePoint 连接器 V2.0/API [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

**注意**  
SharePoint 连接器 V1.0/ SharePointConfiguration API 于 2023 年结束。我们建议迁移到或使用 SharePoint 连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra SharePoint 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [SharePoint 连接器 V1.0](data-source-v1-sharepoint.md)
+ [SharePoint 连接器 V2.0](data-source-v2-sharepoint.md)

# SharePoint 连接器 V1.0
<a name="data-source-v1-sharepoint"></a>

SharePoint 是一项协作建站服务，可用于自定义 Web 内容以及创建页面、网站、文档库和列表。如果您是 SharePoint 用户，则可以使用索 Amazon Kendra 引您的 SharePoint 数据源。

**注意**  
SharePoint 连接器 V1.0/ SharePointConfiguration API 于 2023 年结束。我们建议迁移到或使用 SharePoint 连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra SharePoint 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v1-sharepoint)
+ [先决条件](#prerequisites-v1-sharepoint)
+ [连接说明](#data-source-procedure-v1-sharepoint)
+ [了解详情](#sharepoint-v1-learn-more)

## 支持的功能
<a name="supported-features-v1-sharepoint"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 更改日志
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v1-sharepoint"></a>

在使用索 Amazon Kendra 引 SharePoint 数据源之前，请在 SharePoint 和 AWS 帐户中进行这些更改。

您需要提供身份验证凭证，这些凭据可以安全地存储在 AWS Secrets Manager 密钥中。

**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

**在中 SharePoint，请确保你有：**
+ 记下了您要编制索引的 SharePoint 网站的网址。
+ ** SharePoint 在线版：**
  + 已记下您的基本身份验证凭证，其中包含具有站点管理员权限的用户名和密码。
  + **可选：**生成的 OAuth 2.0 凭据包含用户名、密码、客户端 ID 和客户机密钥。
  + 使用管理用户在 Azure 门户中停用**安全默认值**。有关在 Azure 门户中管理安全默认设置的更多信息，请参阅 [Microsoft 关于如何设置 enable/disable 安全默认设置的文档](https://learn.microsoft.com/en-us/microsoft-365/business-premium/m365bp-conditional-access?view=o365-worldwide&tabs=secdefaults#security-defaults-1)。
+ **对于 SharePoint 服务器：**
  + 记下您的 SharePoint 服务器域名（活动目录中的 NetBIOS 名称）。您可以使用它以及您的 SharePoint 基本身份验证用户名和密码将 SharePoint 服务器连接到 Amazon Kendra。
**注意**  
如果您使用 SharePoint 服务器并且需要将访问控制列表 (ACL) 转换为电子邮件格式以便根据用户上下文进行筛选，请提供 LDAP 服务器 URL 和 LDAP 搜索库。或者，您也可以使用目录域覆盖。LDAP 服务器 URL 是完整的域名和端口号（例如，ldap://example.com:389）。LDAP 搜索库是域控制器的“example”和“com”。凭借目录域覆盖，您可以使用电子邮件域来代替 LDAP 服务器 URL 和 LDAP 搜索库。例如，username@example.com 的电子邮件域名是“example.com”。如果您不想验证域名，而只想使用您的电子邮件域名，则可以使用此替代方法。
+ 为您的 SharePoint 账户添加了以下权限：

  **对于 SharePoint 清单**
  + 打开项目 - 使用服务器端文件处理程序查看文档的来源。
  + 查看应用程序页面 - 查看表单、视图和应用程序页面。枚举列表。
  + 查看项目 - 查看列表中的项目和文档库中的文档。
  + 查看版本 - 查看列表项或文档的过去版本。

  **对于 SharePoint 网站**
  + 浏览目录-使用 SharePoint 设计器和 Web DAV 界面枚举网站中的文件和文件夹。
  + 浏览用户信息 - 查看有关网站用户的信息。
  + 枚举权限 - 枚举网站、列表、文件夹、文档或列表项的权限。
  + 打开 - 打开网站、列表或文件夹以访问容器内的项目。
  + 使用客户端集成功能-使用 SOAP、WebDAV、客户端对象模型或 SharePoint 设计器界面访问网站。
  + 使用远程接口 - 使用启动客户端应用程序的功能。
  + 查看页面 - 查看网站上的页面。
+ 已选中每个文档在您计划用于同一索引的其他数据源中 SharePoint 以及其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的 AWS 账户，请确保你有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 将您的 SharePoint 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将 SharePoint 数据源连接到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v1-sharepoint"></a>

要 Amazon Kendra 连接到您的 SharePoint 数据源，您必须提供 SharePoint 凭据的详细信息， Amazon Kendra 以便访问您的数据。如果您尚未进行配置， SharePoint 请参 Amazon Kendra 阅[先决条件](#prerequisites-v1-sharepoint)。

------
#### [ Console ]

**要连接 Amazon Kendra 到 SharePoint** 

1. 登录 AWS 管理控制台并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据源**页面上，选择**SharePoint 连接器 v1.0**，然后选择**添加数据源**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 对于**托管方式**-在 “**SharePoint 联**机” 和 “**SharePoint服务器**” 之间进行选择。

      1. **SharePoint在线版**-输入** URLs 特定于您的 SharePoint存储库的站点**。

      1. 对于**SharePoint服务器**-选择您的**SharePoint 版本**，输入** SharePoint 存储库的 URLs 特定站点**，然后输入 **SSL 证书位置**的 Amazon S3 路径。

   1. （仅限SharePoint 服务器）对于 **Web 代理**-输入内部 SharePoint 实例**的主机名**和**端口号**。端口号应为介于 0 到 65535 之间的数值。

   1. 对于**身份验证** - 根据您的使用案例选择以下选项：

      1. 对于 SharePoint 联机-在**基本身份验证和 **OAuth 2.0** 身份验证**之间进行选择。

      1. **对于 SharePoint 服务器-在 “**无**”、“**LDAP**” 和 “手动” 之间进行选择。**

   1. fo **AWS Secrets Manager r secre** t-选择现有密钥或创建新 Secrets Manager 密钥来存储您的 SharePoint身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。您必须输入**密钥名称**。前缀 “AmazonKendra-SharePoint-” 会自动添加到您的密钥名称中。

   1. 在**创建 AWS Secrets Manager 密钥窗口**中输入其他信息：

      1. 根据您的用例，从以下 SharePoint Cloud 身份验证选项中进行选择：

         1. **基本身份验证**-输入您的 SharePoint 帐户用户名作为**用户名**，将 SharePoint 帐户密码输入为**密码**。

         1. **OAuth 2.0 身份验证**-输入您的 SharePoint 帐户用户名作为**用户名**，将 SharePoint帐户密码输入为**密码**，将自动生成的唯一 SharePoint ID 作为**客户端 ID**， SharePoint 以及两者使用的共享密钥字符串 Amazon Kendra 作为**客户机**密。

      1. 根据您的用例，从以下 SharePoint服务器身份验证选项中进行选择：

         1. **无**-输入您的 SharePoint 帐户用户名作为**用户名**，将您的 SharePoint 帐户密码输入为**密码**，并输入您的**服务器域名**。

         1. **LDAP** —输入您的 SharePoint 帐户用户名作为**用户名**，将 SharePoint帐户密码输入为**密码**，输入您的 **LDAP 服务器端点**（例如包括协议和端口号*ldap://example.com:389*），以及您的 **LDAP 搜索库**（例如*dc=example, dc=com*）。

         1. **手动**-输入您的 SharePoint 帐户用户名作为**用户名**，将您的 SharePoint 帐户密码输入为**密码**，并输入您的**电子邮件域覆盖**（目录用户或群组的电子邮件域）。

      1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您还必须添加**子网**和 **VPC 安全组**。
**注意**  
如果您使用 SharePoint 服务器，则必须使用 VPC。 Amazon VPC 对于其他 SharePoint版本是可选的。

   1. **IAM ro** le —选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **使用更改日志** - 选择更新索引，而不是同步所有文件。

   1. **爬取附件** - 选择此选项可爬取附件。

   1. **使用本地组映射** - 选择此选项可确保正确筛选文档。

   1. **其他配置** - 添加正则表达式模式以包含或排除某些文件。最多可以添加 100 个模式。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **Amazon Kendra 默认字段映射**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。

   1. 对于**自定义字段映射** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接 Amazon Kendra 到 SharePoint**

您必须使用 [SharePointConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SharePointConfiguration.html)API 指定以下内容：
+ **SharePoint版本**-指定配置 SharePoint时使用的 SharePoint版本。无论你使用的是 Server 2013、 SharePoint Server 2016、S SharePoint erver 2019 还是 O SharePoint nlin SharePoint e，情况都是如此。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在 SharePoint 账户中创建的身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。密钥存储在 JSON 结构中。

  对于**SharePoint 在线基本身份验证**，以下是您的密钥中必须包含的最低 JSON 结构：

  ```
  {
      "userName": "user name",
      "password": "password"
  }
  ```

  对于 O **SharePoint nline OAuth 2.0 身份验证**，以下是您的密钥中必须包含的最低 JSON 结构：

  ```
  {
      "userName": "SharePoint account user name"",
      "password": "SharePoint account password",
      "clientId": "SharePoint auto-generated unique client id",
      "clientSecret": "secret string shared by Amazon Kendra and SharePoint to authorize communications"
  }
  ```

  对于**SharePoint 服务器基本身份验证**，以下是您的密钥中必须包含的最低 JSON 结构：

  ```
  {
      "userName": "user name",
      "password": "password",
      "domain": "server domain name"
  }
  ```

  对于**SharePoint 服务器 LDAP 身份验证**（如果您需要将访问控制列表 (ACL) 转换为电子邮件格式以便根据用户上下文进行筛选，则可以在密钥中包含 LDAP 服务器 URL 和 LDAP 搜索库），以下是您的密钥中必须包含的最低 JSON 结构：

  ```
  {
      "userName": "user name",
      "password": "password",
      "domain": "server domain name"
      "ldapServerUrl": "ldap://example.com:389",
      "ldapSearchBase": "dc=example,dc=com"
  }
  ```

  对于**SharePoint 服务器手动身份验证**，以下是您的密钥中必须包含的最低 JSON 结构：

  ```
  {
      "userName": "user name",
      "password": "password",
      "domain": "server domain name",
      "emailDomainOverride": "example.com"
  }
  ```
+ **IAM ro** le —指定`RoleArn`何时调用`CreateDataSource`以向 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及调用 SharePoint 连接器 APIs 所需的公众的权限，以及 Amazon Kendra。有关更多信息，请参阅 [ SharePoint S3 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。
+  **Amazon VPC**—如果您使用 SharePoint 服务器`VpcConfiguration`，请在数据源配置中指定。请参阅[配置 Amazon Kendra 以使用 VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。

您还可以添加以下可选功能：
+ **Web 代理**-是否 URLs 通过 Web 代理连接到您的 SharePoint 站点。此选项只能用于 SharePoint服务器。
+ **索引列表**-是否 Amazon Kendra 应将附件的内容编入 SharePoint 列表项的索引。
+  **更改日志**-是否 Amazon Kendra 应使用 SharePoint 数据源更改日志机制来确定是否必须更新索引中的文档。
**注意**  
如果您不想让 Amazon Kendra 扫描所有文档，请使用更改日志。如果您的更改日志很大，则扫描 SharePoint 数据源中的文档所花费的时间可能比处理更改日志所需的时间 Amazon Kendra 少。如果您是首次将 SharePoint数据源与索引同步，则会扫描所有文档。
+  **包含和排除筛选条件** - 您可以指定是包含还是排除某些内容。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **字段映射** - 选择将 SharePoint 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。

------

## 了解详情
<a name="sharepoint-v1-learn-more"></a>

要了解有关 Amazon Kendra 与 SharePoint数据源集成的更多信息，请参阅：
+ [Amazon Kendra SharePoint 在线连接器入门](https://aws.amazon.com/blogs/machine-learning/getting-started-with-the-amazon-kendra-sharepoint-online-connector/)

# SharePoint 连接器 V2.0
<a name="data-source-v2-sharepoint"></a>

SharePoint 是一项协作建站服务，可用于自定义 Web 内容以及创建页面、网站、文档库和列表。您可以使用索 Amazon Kendra 引您的 SharePoint 数据源。

Amazon Kendra 目前支持 SharePoint 在线版和 SharePoint服务器版（2013 年、2016 年、2019 年和订阅版）。

**注意**  
SharePoint 连接器 V1.0/ SharePointConfiguration API 于 2023 年结束。我们建议迁移到或使用 SharePoint 连接器 V2.0/ TemplateConfiguration API。

要对 Amazon Kendra SharePoint 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v2-sharepoint)
+ [先决条件](#prerequisites-v2-sharepoint)
+ [连接说明](#data-source-procedure-v2-sharepoint)
+ [注意](#sharepoint-notes)

## 支持的功能
<a name="supported-features-v2-sharepoint"></a>

Amazon Kendra SharePoint 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v2-sharepoint"></a>

在使用索 Amazon Kendra 引 SharePoint 数据源之前，请在 SharePoint 和 AWS 帐户中进行这些更改。

您需要提供身份验证凭证，这些凭据可以安全地存储在 AWS Secrets Manager 密钥中。

**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

**在 “在 SharePoint 线” 中，请确保你有：**
+ 已复制您的 SharePoint 实例 URLs。您输入的主机 URL 的格式为*https://yourdomain.com/sites/mysite*。您的 URL 必须以 `https` 开头。
+ 已复制您的 SharePoint 实例 URL 的域名。
+ 已记下您的基本身份验证凭据，其中包含用户名和密码，具有连接到 On SharePoint line 的站点管理员权限。
+ 使用管理用户在 Azure 门户中停用**安全默认值**。有关在 Azure 门户中管理安全默认设置的更多信息，请参阅 [Microsoft 关于如何设置 enable/disable 安全默认设置的文档](https://learn.microsoft.com/en-us/microsoft-365/business-premium/m365bp-conditional-access?view=o365-worldwide&tabs=secdefaults#security-defaults-1)。
+ 已在您的 SharePoint账户中停用多因素身份验证 (MFA)，这样就不会阻止 Amazon Kendra 它抓取您的内容。 SharePoint 
+ **如果使用基本身份验证以外的身份验证类型：**已复制 SharePoint 实例的租户 ID。有关如何查找租户 ID 的详细信息，请参阅[查找您的 Microsoft 365 租户 ID](https://learn.microsoft.com/en-us/sharepoint/find-your-office-365-tenant-id)。
+ 如果您需要迁移到 Microsoft Entra 云用户身份验证，请参阅 [Microsoft 关于云身份验证的文档](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/migrate-from-federation-to-cloud-authentication)。
+ **对于 OAuth 2.0 身份验证和 OAuth 2.0 刷新令牌身份验证：**记下您的**基本身份验证**凭据，其中包含用于连接到 On SharePoint line 的用户名和密码以及注册 SharePoint 到 Azure AD 后生成的客户端 ID 和客户端密钥。
  + **如果您未使用 ACL**，请添加以下权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-v2-sharepoint.html)
**注意**  
Note.Read.All 和 Sites.Read.All 只有在你想抓取 Documents 时才是必填的。 OneNote   
如果要爬取特定网站，您可以选择将权限限制为特定网站，而不是域中所有可用的网站。您配置 **Sites.Selected（应用程序）**权限。对于此 API 权限，您需要通过 Microsoft Graph API 明确设置每个站点上的访问权限。有关更多信息，请参阅 [Microsoft 有关 Sites.Selected 权限的博客](https://techcommunity.microsoft.com/t5/microsoft-sharepoint-blog/develop-applications-that-use-sites-selected-permissions-for-spo/ba-p/3790476)。
  + **如果您使用 ACL**，请添加以下权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-v2-sharepoint.html)
**注意**  
GroupMember**只有激活 Identity Crawler 时，才需要.Read.All 和 User.Read.All。**  
如果要爬取特定网站，您可以选择将权限限制为特定网站，而不是域中所有可用的网站。您配置 **Sites.Selected（应用程序）**权限。对于此 API 权限，您需要通过 Microsoft Graph API 明确设置每个站点上的访问权限。有关更多信息，请参阅 [Microsoft 有关 Sites.Selected 权限的博客](https://techcommunity.microsoft.com/t5/microsoft-sharepoint-blog/develop-applications-that-use-sites-selected-permissions-for-spo/ba-p/3790476)。
+ **对于 Azure AD 仅限应用程序的身份验证：**私钥和注册 SharePoint 到 Azure AD 后生成的客户端 ID。还要记下 X.509 证书。
  + **如果您未使用 ACL**，请添加以下权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-v2-sharepoint.html)
**注意**  
如果要爬取特定网站，您可以选择将权限限制为特定网站，而不是域中所有可用的网站。您配置 **Sites.Selected（应用程序）**权限。对于此 API 权限，您需要通过 Microsoft Graph API 明确设置每个站点上的访问权限。有关更多信息，请参阅 [Microsoft 有关 Sites.Selected 权限的博客](https://techcommunity.microsoft.com/t5/microsoft-sharepoint-blog/develop-applications-that-use-sites-selected-permissions-for-spo/ba-p/3790476)。
  + **如果您使用 ACL**，请添加以下权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-v2-sharepoint.html)
**注意**  
如果要爬取特定网站，您可以选择将权限限制为特定网站，而不是域中所有可用的网站。您配置 **Sites.Selected（应用程序）**权限。对于此 API 权限，您需要通过 Microsoft Graph API 明确设置每个站点上的访问权限。有关更多信息，请参阅 [Microsoft 有关 Sites.Selected 权限的博客](https://techcommunity.microsoft.com/t5/microsoft-sharepoint-blog/develop-applications-that-use-sites-selected-permissions-for-spo/ba-p/3790476)。
+ **对于 SharePoint 仅限应用程序的身份验证：**记下在授予 “仅限 SharePoint 应用程序” 权限时生成的客户端 ID 和客户端密钥，以及向 Azure AD 注册 SharePoint 应用程序时生成的客户端 ID 和客户端密钥。 SharePoint 
**注意**  
SharePoint SharePoint 2013 版本*不*支持仅限应用程序的身份验证。
  + **（可选）如果您正在搜索 OneNote文档并使用 Id **entity Crawler****，请添加以下权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-v2-sharepoint.html)
**注意**  
使用**基本身份验证和仅限 SharePoint应用程序的身份验证****来抓取实体不需要 AP** I 权限。

**在 SharePoint 服务器中，请确保你有：**
+ 已复制您的 SharePoint 实例 URLs 和您的域名 SharePoint URLs。您输入的主机 URL 的格式为*https://yourcompany/sites/mysite*。您的 URL 必须以 `https` 开头。
**注意**  
（本地/服务器） Amazon Kendra 会检查中 AWS Secrets Manager 包含的端点信息是否与数据源配置详细信息中指定的端点信息相同。这有助于防止出现[混淆代理人问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)，这是一个安全问题，即用户无权执行操作，但可以将 Amazon Kendra 作为代理来访问配置的密钥和执行操作。如果以后更改端点信息，则必须创建一个新密钥来同步此信息。
+ 已在您的 SharePoint账户中停用多因素身份验证 (MFA)，这样就不会阻止 Amazon Kendra 它抓取您的内容。 SharePoint 
+ 如果使用**SharePoint 仅限应用程序的身份验证进行**访问控制：
  + 已复制您在站点级别注册 “仅限应用程序” 时生成的 SharePoint 客户端 ID。客户端 ID 格式为 ClientId @ TenantId。例如 *ffa956f3-8f89-44e7-b0e4-49670756342c@888d0b57-69f1-4fb8-957f-e1f0bedf82fe*。
  + 已复制您在站点级别注册 “仅限应用程序” 时生成的 SharePoint 客户端密钥。

  **注意：**由于只有在注册 SharePoint 服务器进行仅限应用程序身份验证时，才会为单个站点生成客户端 IDs 和客户端密钥，因此仅 SharePoint 应用程序身份验证仅支持一个站点 URL。
**注意**  
SharePoint SharePoint 2013 版本*不*支持仅限应用程序的身份验证。
+ 如果使用**带有自定义域名的电子邮件 ID** 进行访问控制：
  + 记下了您的自定义电子邮件域值，例如：“”。*amazon.com*
+ 如果使用**带有来自 IDP 的域名的电子邮件 ID** 身份验证，请复制您的：
  + LDAP 服务器端点（LDAP 服务器的端点，包括协议和端口号）。例如：*ldap://example.com:389*。
  + LDAP 搜索库（LDAP 用户的搜索库）。例如：*CN=Users,DC=sharepoint,DC=com*。
  + LDAP 用户名和 LDAP 密码。
+ 要么配置了 NTLM 身份验证凭据，要**么**配置了包含用户名（SharePoint 帐户用户名）和密码（SharePoint 帐户密码）的 Kerberos 身份验证凭据。

**在你的 AWS 账户，请确保你有：**
+ [已创建 Amazon Kendra 索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。 IAM 
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的 IAM 角色才能访问正确的 AWS Secrets Manager 密钥 ID。
+ 将您的 SharePoint 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的 IAM 角色或密钥，则可以在将 SharePoint 数据源连接到时使用控制台创建新的 IAM 角色和 Secrets Manager 密钥 Amazon Kendra。如果您使用的是 API，则必须提供现有 IAM 角色和 Secrets Manager 密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v2-sharepoint"></a>

要 Amazon Kendra 连接到您的 SharePoint 数据源，您必须提供 SharePoint 凭据的详细信息， Amazon Kendra 以便访问您的数据。如果您尚未进行配置， SharePoint 请参 Amazon Kendra 阅[先决条件](#prerequisites-v2-sharepoint)。

------
#### [ Console: SharePoint Online ]

**连接 Amazon Kendra 到 “在 SharePoint 线”** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **SharePoint 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **SharePoint 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **托管方式**-选择**SharePoint在线**。

   1. ** SharePoint存储库的 URLs 特定站点**-输入 SharePoint 主机 URLs。 URLs 您输入的主机格式为*https://yourdomain.sharepoint.com/sites/mysite*。URL 必须以 `https` 协议开头。 URLs 用新行分隔。您最多可以添加 100 URLs。

   1. **域**-输入 SharePoint 域。例如，URL 中的域*https://yourdomain.sharepoint.com/sites/mysite*是*yourdomain*。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

      您还可以选择用户 ID 的类型，无论是用户主体名称还是从 Azure 门户获取的用户电子邮件。如果您不指定，默认情况下使用电子邮件。

   1. **身份验证**-选择基本、 OAuth 2.0、仅限 Azure AD 应用程序身份验证、仅限应用程序身份验证或 OAuth 2.0 SharePoint 刷新令牌身份验证。您可以选择现有 AWS Secrets Manager 密钥或创建一个密钥来存储您的身份验证凭证。

      1. 如果使用**基本身份验证**，则您的密钥必须包含机密名称、 SharePoint 用户名和密码。

      1. 如果使用 **OAuth 2.0 身份验证**，则密钥必须包括 SharePoint 租户 ID、密钥名称、 SharePoint 用户名、密码、在 Azure AD SharePoint 中注册时生成的 Azure AD 客户端 ID 以及在 Azure AD SharePoint 中注册时生成的 Azure AD 客户端密钥。

      1. 如果使用**仅限 Azure AD 应用程序的身份验证**，则您的密钥必须包括 SharePoint 租户 ID、Azure AD 自签名 X.509 证书、密钥名称、在 Azure AD SharePoint 中注册时生成的 Azure AD 客户端 ID 以及用于对 Azure AD 连接器进行身份验证的私钥。

      1. 如果使用**SharePoint仅限应用程序的身份验证**，则密钥必须包括 SharePoint 租户 ID、密钥名称、在租户级别注册 “仅限应用程序” 时生成的 SharePoint 客户端 ID、在租户级别注册仅限应用程序时生成的 SharePoint 客户端密钥、在 Azure AD SharePoint 中注册时生成的 Azure AD 客户端 ID 以及注册 SharePoint 到 Azure AD 时生成的 Azure AD 客户端密钥。

          SharePoint 客户端 ID 的格式为*ClientID@TenantId*。例如 *ffa956f3-8f89-44e7-b0e4-49670756342c@888d0b57-69f1-4fb8-957f-e1f0bedf82fe*。

      1. 如果使用 **OAuth 2.0 刷新令牌身份验证**，则您的密钥必须包括 SharePoint 租户 ID、密钥名称、在 Azure AD SharePoint 中注册时生成的唯一 Azure AD 客户端 ID、注册到 Azure AD 时生成的 Azure AD 客户端密钥、为连接 Amazon Kendra 而生成的刷新令牌 SharePoint。 SharePoint 

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

      您也可以选择爬取本地组映射或 Azure Active Directory 组映射。
**注意**  
AD 组映射抓取仅适用于 OAuth 2.0、 OAuth 2.0 刷新令牌和仅限 SharePoint 应用程序的身份验证。

   1. **IAM ro** le —选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：

      1. **选择实体** - 选择要爬取的实体。您可以选择爬取**所有**实体或**文件**、**附件**、**链接**、**页面**、**事件**、**备注**和**列表数据**的任意组合。

      1. 在**其他配置**中，对于**实体正则表达式模式** - 为**链接**、**页面**和**事件**添加正则表达式模式以包含特定实体，而不是同步所有文档。

      1. 正则@@ **表达式模式**-添加正则表达式模式，通过文件**路径、文件**名、****文件类型**、OneNote 章节名称****和**OneNote 页面名称****来包含或排除文件，而不是同步所有文档。最多可以添加 100 个。
**注意**  
OneNote 抓取仅适用于 OAuth 2.0、 OAuth 2.0 刷新令牌和仅限 SharePoint 应用程序的身份验证。

   1. 对于**同步模式** - 选择在数据来源内容发生变化时更新索引的方式。首次将数据来源与 Amazon Kendra 同步时，所有内容都会默认同步。
      + **完全同步** - 无论之前的同步状态如何，都同步所有内容。
      + **同步新增或修改的文档** - 仅同步新增或修改的文档。
      + **同步新增、修改或删除的文档** - 仅同步新增、修改和删除的文档。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ Console: SharePoint Server ]

**要连接 Amazon Kendra 到 SharePoint** 

1. 登录 AWS 管理控制台 并打开[Amazon Kendra 控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **SharePoint 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **SharePoint 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的 AWS 成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **托管方法**-选择**SharePoint服务器。**

   1. **选择 SharePoint版本**-选择 **SharePoint 2013 年、SharePoint 201** **6 年、201 SharePoint ** **9 年**和 **SharePoint （订阅版）**。

   1. ** SharePoint存储库的 URLs 特定站点**-输入 SharePoint 主机 URLs。 URLs 您输入的主机格式为*https://yourcompany/sites/mysite*。URL 必须以 `https` 协议开头。 URLs 用新行分隔。您最多可以添加 100 URLs。

   1. **域**-输入 SharePoint 域。例如，URL 中的域名*https://yourcompany/sites/mysite*是 *yourcompany*

   1. **SSL 证书位置**-输入 SSL 证书文件的 Amazon S3 路径。

   1. （可选）对于 **Web 代理** - 输入主机名（不带 `http://` 或 `https://` 协议）和主机 URL 传输协议使用的端口号。端口号的数值必须介于 0 和 65535 之间。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

      对于 SharePoint 服务器，您可以从以下 ACL 选项中进行选择：

      1. 包含@@ **来自 IDP 的域名的电子邮件 ID**-用户 ID 基于从底层身份提供商 (IDP) 获取的域名的电子邮件 IDs 。在**身份验证**期间，您可以在 Secrets Manager 密钥中提供 IDP 连接详细信息。

      1. **带有自定义域的电子邮件 ID** - 用户 ID 基于自定义的电子邮件域值。例如，“*amazon.com*”。电子邮件域名将用于构造用于访问控制的电子邮件 ID。您必须输入您的自定义电子邮件域。

      1. **域\$1带域的用户** - 用户 ID 采用“域\$1用户 ID”的格式。您需要提供有效的域名。例如：构造*"sharepoint2019"*访问控制。

   1. 对于**身份验证**，请选择 SharePoint 仅限应用程序身份验证、NTLM 身份验证或 Kerberos 身份验证。您可以选择现有 AWS Secrets Manager 密钥或创建一个密钥来存储您的身份验证凭证。

      1. 如果使用 **NTLM 身份验证**或 **Kerberos 身份验证**，则您的密钥必须包含密钥名称、 SharePoint 用户名和密码。

         如果使用**带有来自 IDP 的域名的电子邮件 ID**，请同时输入您的：
         +  **LDAP 服务器端点** - LDAP 服务器的端点，包括协议和端口号。例如：*ldap://example.com:389*。
         + **LDAP 搜索库** - LDAP 用户的搜索库。例如：*CN=Users,DC=sharepoint,DC=com*。
         + **LDAP 用户名** - 您的 LDAP 用户名。
         + **LDAP 密码** - 您的 LDAP 密码。

      1. 如果使用**SharePoint仅限应用程序的身份验证**，则您的密钥必须包含密钥名称，即您在站点级别注册仅限应用程序时生成的客户 SharePoint端 ID，在站点级别注册仅限应用程序时生成的 SharePoint 客户端密钥。

          SharePoint 客户端 ID 的格式为*ClientID@TenantId*。例如 *ffa956f3-8f89-44e7-b0e4-49670756342c@888d0b57-69f1-4fb8-957f-e1f0bedf82fe*。

         **注意：**由于只有在注册 SharePoint 服务器进行仅限应用程序身份验证时，才会为单个站点生成客户端 IDs 和客户端密钥，因此仅 SharePoint 应用程序身份验证仅支持一个站点 URL。

         如果使用**带有来自 IDP 的域名的电子邮件 ID**，请同时输入您的：
         +  **LDAP 服务器端点** - LDAP 服务器的端点，包括协议和端口号。例如：*ldap://example.com:389*。
         + **LDAP 搜索库** - LDAP 用户的搜索库。例如：*CN=Users,DC=sharepoint,DC=com*。
         + **LDAP 用户名** - 您的 LDAP 用户名。
         + **LDAP 密码** - 您的 LDAP 密码。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

      您也可以选择爬取本地组映射或 Azure Active Directory 组映射。
**注意**  
AD 组映射抓取仅适用于 SharePoint 应用程序身份验证。

   1. **IAM ro** le —选择现有 IAM 角色或创建新 IAM 角色来访问您的存储库凭据和索引内容。
**注意**  
IAM 用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：

      1. **选择实体** - 选择要爬取的实体。您可以选择爬取**所有**实体或**文件**、**附件**、**链接**、**页面**、**事件**和**列表数据**的任意组合。

      1. 在**其他配置**中，对于**实体正则表达式模式** - 为**链接**、**页面**和**事件**添加正则表达式模式以包含特定实体，而不是同步所有文档。

      1. 正则@@ **表达式模式**-添加正则表达式模式，通过**文件路径文件名文件******类型**、OneNote章节名称****和**OneNote页面名称****来包含或排除文件，而不是同步所有文档。最多可以添加 100 个。
**注意**  
OneNote 抓取仅适用于 “仅限 SharePoint 应用程序” 的身份验证。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 修改过的新同步：每次数据源与索引同步时，仅为新增和修改过的内容编制索引。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
      + 新增、修改、删除的同步：每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。 Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从 Amazon Kendra 生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接 Amazon Kendra 到 SharePoint**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `SHAREPOINTV2`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **存储库端点元数据**-指定 SharePoint 实例`siteUrls`的`tenantID``domain`和。
+ **同步模式**-指定数据源内容发生变化时 Amazon Kendra 应如何更新索引。首次与同步数据源时， Amazon Kendra 默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`每次数据源与索引同步时，仅对新的、修改过的和已删除的内容编制索引。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
  + `CHANGE_LOG`每次数据源与索引同步时，仅索引新的和修改过的内容。 Amazon Kendra 可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果 Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
**注意**  
只有当您将 `crawlAcl` 设置为 `true` 时，身份爬网程序才可用。
+ **存储库其他属性** - 指定：
  + （仅适用于 Azure AD）用于存储 Azure AD 自签名 X.509 证书的 `s3bucketName` 和 `s3certificateName`。
  + 您使用的身份验证类型（`auth_Type`），包括 `OAuth2`、`OAuth2App`、`OAuth2Certificate`、`Basic`、`OAuth2_RefreshToken`、`NTLM` 和 `Kerberos`。
  + 您使用的版本（`version`），包括 `Server` 或 `Online`。如果使用 `Server`，您可以进一步将 `onPremVersion` 指定为 `2013`、`2016`、`2019` 或 `SubscriptionEdition`。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的 Secrets Manager 密钥的亚马逊资源名称 (ARN)。 SharePoint 

  如果使用 SharePoint 联机，则可以在基本身份验证、 OAuth 2.0、仅限 Azure AD 应用程序身份验证和仅限 SharePoint 应用程序身份验证之间进行选择。以下是每个身份验证选项的密钥中必须包含的最简单 JSON 结构：
  + **基本身份验证**

    ```
    {
        "userName": "SharePoint account user name",
        "password": "SharePoint account password"
    }
    ```
  + **OAuth 2.0 身份验证**

    ```
    {
        "clientId": "client id generated when registering SharePoint with Azure AD",
        "clientSecret": "client secret generated when registering SharePoint with Azure AD",
        "userName": "SharePoint account user name",
        "password": "SharePoint account password"
    }
    ```
  + **仅限 Azure AD 应用程序的身份验证**

    ```
    {
        "clientId": "client id generated when registering SharePoint with Azure AD",
        "privateKey": "private key to authorize connection with Azure AD"
    }
    ```
  + **SharePoint 仅限应用程序的身份验证**

    ```
    {
        "clientId": "client id generated when registering SharePoint for App Only at Tenant Level",
        "clientSecret": "client secret generated when registering SharePoint for App Only at Tenant Level",
        "adClientId": "client id generated while registering SharePoint with Azure AD",
        "adClientSecret": "client secret generated while registering SharePoint with Azure AD"
    }
    ```
  + **OAuth 2.0 刷新令牌身份验证**

    ```
    {
        "clientId": "client id generated when registering SharePoint with Azure AD",
        "clientSecret": "client secret generated when registering SharePoint with Azure AD",
        "refreshToken": "refresh token generated to connect to SharePoint"
    }
    ```

  如果您使用 SharePoint 服务器，则可以在 SharePoint 仅限应用程序身份验证、NTLM 身份验证和 Kerberos 身份验证之间进行选择。以下是每个身份验证选项的密钥中必须包含的最简单 JSON 结构：
  + ** SharePoint 仅限应用程序的身份验证**

    ```
    {
        "siteUrlsHash": "Hash representation of SharePoint site URLs",
        "clientId": "client id generated when registering SharePoint for App Only at Site Level",
        "clientSecret": "client secret generated when registering SharePoint for App Only at Site Level" 
    }
    ```
  + ** SharePoint 使用来自 IDP 授权的域进行仅限应用程序的身份验证**

    ```
    {
        "siteUrlsHash": "Hash representation of SharePoint site URLs",
        "clientId": "client id generated when registering SharePoint for App Only at Site Level",
        "clientSecret": "client secret generated when registering SharePoint for App Only at Site Level",
        "ldapUrl": "LDAP Account url eg. ldap://example.com:389",
        "baseDn": "LDAP Account base dn eg. CN=Users,DC=sharepoint,DC=com",
        "ldapUser": "LDAP account user name",
        "ldapPassword": "LDAP account password"
    }
    ```
  + **（仅限服务器）NTLM 或 Kerberos 身份验证**

    ```
    {
        "siteUrlsHash": "Hash representation of SharePoint site URLs",
        "userName": "SharePoint account user name",
        "password": "SharePoint account password"
    }
    ```
  + **（仅限服务器）带有来自 IDP 授权的域名的 NTLM 或 Kerberos 身份验证**

    ```
    {
        "siteUrlsHash": "Hash representation of SharePoint site URLs",
        "userName": "SharePoint account user name",
        "password": "SharePoint account password",
        "ldapUrl": "ldap://example.com:389",
        "baseDn": "CN=Users,DC=sharepoint,DC=com",
        "ldapUser": "LDAP account user name",
        "ldapPassword": "LDAP account password"
    }
    ```
+ **IAM ro** le —指定`RoleArn`何时调用`CreateDataSource`以向 IAM 角色提供访问您的 Secrets Manager 密钥的权限以及调用 SharePoint 连接器 APIs 所需的公众的权限，以及 Amazon Kendra。有关更多信息，请参阅 [ SharePoint S3 数据来源的IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以指定是包含还是排除某些文件和其他内容。 OneNotes
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **字段映射** - 选择将 SharePoint 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。 Amazon Kendra 您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [SharePoint 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-schema-sharepoint)。

------

## 注意
<a name="sharepoint-notes"></a>
+ 连接器仅支持**文件**实体的自定义字段映射。
+ 对于所有 SharePoint 服务器版本，ACL 令牌必须为小写。对于**包含来自 IDP 的域名**和**带有自定义域 ACL 的电子邮件 ID** 的电子邮件，例如：*user@sharepoint2019.com*。对于**具有域 ACL 的域\$1 用户**，例如：*sharepoint2013\$1user*。
+ 启用访问控制列表 (ACLs) 后，由于 SharePoint API 限制，“仅同步新内容或修改内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。
+ 连接器不支持 SharePoint 2013 年的更改日志模式/ **新内容或修改内容同步**。
+ 如果实体名称中包含字 `%` 符，则由于 API 限制，连接器将跳过这些文件。
+ OneNote 只能由连接器使用租户 ID 进行抓取，并激活了 OAuth 2.0、 OAuth 2.0 刷新令牌或仅限 SharePoint 应用程序的身份验证 SharePoint 。
+ 连接器仅使用 OneNote 文档的默认名称抓取文档的第一部分，即使文档已重命名也是如此。
+ **连接器会抓取 SharePoint 2019 年、 SharePoint在线版和订阅版中的链接，前提是除了链接之外还选择 “**页面**” 和 “**文件**” 作为要抓取的实体。**
+ 如果选择链接作为要抓取的实体，则连接器会在 SharePoint SharePoint 2013 年和 2016 年抓取**链接**。
+ 仅当**列表数据**也被选为要爬取的实体时，连接器才会爬取列表附件和评论。
+ 仅当**事件**也被选为要爬取的实体时，连接器才会爬取事件附件。
+ 对于 SharePoint 在线版本，ACL 令牌将使用小写。例如，如果**用户主体名称**位于 Azure 门户*MaryMajor@domain.com*中，则 SharePoint 连接器中的 ACL 令牌将是*marymajor@domain.com*。
+ 在 **Identity Crawler f** or O SharePoint nline 和 Server 中，如果要抓取嵌套群组，则必须激活本地和 AD 组抓取。
+ 如果你使用的是 O SharePoint nline，并且 Azure 门户中的用户主体名称是大写和小写的组合，那么 SharePoint API 会在内部将其转换为小写。因此， Amazon Kendra SharePoint 连接器以小写形式设置 ACL。

# Microsoft SQL Server
<a name="data-source-ms-sql-server"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Microsoft SQL Server 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Microsoft SQL Server 是 Microsoft 开发的一个关系数据库管理系统（RDBMS）。如果您是Microsoft SQL Server用户，则可以使用索Amazon Kendra引您的Microsoft SQL Server数据源。Amazon KendraMicrosoft SQL Server数据源连接器支持 MS SQL Server 2019。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Microsoft SQL Server数据源。

要对Amazon KendraMicrosoft SQL Server数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-ms-sql-server)
+ [先决条件](#prerequisites-ms-sql-server)
+ [连接说明](#data-source-procedure-ms-sql-server)
+ [注意](#ms-sql-server-notes)

## 支持的功能
<a name="supported-features-ms-sql-server"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-ms-sql-server"></a>

在使用索Amazon Kendra引Microsoft SQL Server数据源之前，请在Microsoft SQL Server和AWS帐户中进行这些更改。

**在 Microsoft SQL Server 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 在 Microsoft SQL Server 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Microsoft SQL Server 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Microsoft SQL Server数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-ms-sql-server"></a>

要Amazon Kendra连接到您的Microsoft SQL Server数据源，您必须提供Microsoft SQL Server凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，Microsoft SQL Server请参Amazon Kendra阅[先决条件](#prerequisites-ms-sql-server)。

------
#### [ Console ]

**要连接Amazon Kendra到 Microsoft SQL Server** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Microsoft SQL Server 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Microsoft SQL Server 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** - 输入数据库主机名。

   1.  **端口** - 输入数据库端口。

   1.  **实例** - 输入数据库实例。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的Microsoft SQL Server身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Microsoft SQL Server-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
**注意**  
如果表名中包含特殊字符（非字母数字），则必须使用方括号将表名括起来。例如，*select \$1 from [my-database-table]*
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + **用户 IDs列**-输入包含允许用户访问内容 IDs 的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（**文档 IDs**、**文档标题**和**来源 URLs**）中选择要映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Microsoft SQL Server**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `sqlserver`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
**注意**  
如果表名中包含特殊字符（非字母数字），则必须使用方括号将表名括起来。例如，*select \$1 from [my-database-table]*
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。Microsoft SQL Server密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Microsoft SQL Server连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Microsoft SQL Server S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Microsoft SQL Server 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Microsoft SQL Server 模板架构](ds-schemas.md#ds-ms-sql-server-schema)。

------

## 注意
<a name="ms-sql-server-notes"></a>
+ 在Amazon Kendra检查更新内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Microsoft Teams
<a name="data-source-teams"></a>

Microsoft Teams 是一款用于消息、会议和文件共享的企业协作工具。如果你是微软 Teams 用户，你可以使用Amazon Kendra索引你的 Microsoft Teams 数据源。

你可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到你的 Microsoft Teams 数据源。

要对 Amazon Kendra Microsoft Teams 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-teams)
+ [先决条件](#prerequisites-teams)
+ [连接说明](#data-source-procedure-teams)
+ [了解详情](#teams-learn-more)
+ [注意](#teams-notes)

## 支持的功能
<a name="supported-features-teams"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-teams"></a>

在使用Amazon Kendra索引你的 Microsoft Teams 数据源之前，请在你的微软 Teams 和AWS账户中进行这些更改。

**在 Microsoft Teams 中，请确保：**
+ 在 Office 365 中创建了一个 Microsoft Teams 账户。
+ 记下了您的 Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。
+ 在 Azure 门户中配置了 OAuth 应用程序，并记下了客户端 ID 和客户端密钥或客户端凭据。有关更多信息，请参阅 [Microsoft 教程](https://learn.microsoft.com/en-us/power-apps/developer/data-platform/walkthrough-register-app-azure-active-directory)和[注册应用程序示例](https://learn.microsoft.com/en-us/azure/healthcare-apis/register-application)。
**注意**  
当您在 Azure 门户中创建或注册应用程序时，密钥 ID 代表实际的密钥值。在创建密钥和应用程序时，您必须立即记下或保存该实际的密钥值。您可以通过在 Azure 门户中选择应用程序名称，然后导航到有关证书和密钥的菜单选项来访问您的密钥。  
您可以通过在 Azure 门户中选择应用程序名称，然后导航到概述页面来访问您的客户端 ID。其中的“应用程序（客户端）ID”即是客户端 ID。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 添加必要的权限。您可以选择添加所有权限，也可以根据要爬取的实体选择更少的权限来限制范围。下表列出了各实体对应的应用程序级权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-teams.html)
+ 在 Microsoft Teams 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Microsoft Teams 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果你没有现有的IAM角色或密钥，则可以在将 Microsoft Teams 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-teams"></a>

Amazon Kendra要连接到你的 Microsoft Teams 数据源，你必须提供微软 Teams 数据源的必要详细信息，这样Amazon Kendra才能访问你的数据。如果你尚未为其配置 Microsoft Team Amazon Kendra s，请参阅[先决条件](#prerequisites-teams)。

------
#### [ Console ]

**连接微软 Amazon Kendra Teams** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Microsoft Teams 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Microsoft Teams 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **租户 ID** - 输入您的 Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **AWS Secrets Manager密钥** — 选择现有密钥或创建新Secrets Manager密钥来存储你的 Microsoft Teams 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Microsoft Teams-” 会自动添加到你的密钥名称中。

         1. 对于**客户端 ID** 和**客户端密钥** - 输入您在 Azure 门户中从您的 Microsoft Teams 账户生成的身份验证凭证值。

      1. 保存并添加您的密钥。

   1. **付款模式** - 您可以为您的 Microsoft Teams 账户选择许可和付款模式。A 型支付模式仅限于需要安全合规的许可和支付模式。B 型支付模式适用于不需要安全合规的许可和支付模式。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **同步内容** - 选择要爬取的内容类型。您可以选择爬取聊天、团队和日历内容。

   1. **其他配置** —指定特定的日历开始和结束日期、用户电子邮件、团队名称和频道名称、附件和 OneNotes。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接微软 Amazon Kendra Teams**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `MSTEAMS`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **租户 ID**-你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含你的 Microsoft Teams 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "clientId": "client ID",
      "clientSecret": "client secret"
  }
  ```
+ **IAM角色** —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用 Microsoft Teams 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Microsoft Teams 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **文档/内容类型** - 指定是否爬取以下内容：聊天消息和附件、频道帖子和附件、频道 WiKi、日历内容、会议聊天和文件以及备忘录。
+ **日历内容** - 指定爬取日历内容的开始和结束日期时间。
+ **包含和排除筛选条件** - 指定是包含还是排除 Microsoft Teams 中的某些内容。您可以包含或排除团队名称、频道名称、文件名和文件类型、用户电子邮件、 OneNote 分区和 OneNote 页面。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Microsoft Teams 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Microsoft Teams 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-msteams-schema)。

------

## 了解详情
<a name="teams-learn-more"></a>

要详细了解如何Amazon Kendra与你的 Microsoft Teams 数据源集成，请参阅：
+ [使用微软团队的Amazon Kendra连接器智能搜索组织的 Microsoft Teams 数据源](https://aws.amazon.com/blogs/machine-learning/intelligently-search-your-organizations-microsoft-teams-data-source-with-the-amazon-kendra-connector-for-microsoft-teams/)

## 注意
<a name="teams-notes"></a>
+ 启用访问控制列表 (ACLs) 后，由于 Microsoft Teams API 的限制，“仅同步新内容或修改过的内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。

# Micoft Yammer
<a name="data-source-yammer"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍将为现有客户提供对 Microsoft Yammer 连接器的完全支持。该连接器虽已不再面向新用户开放，但现有用户可继续无中断使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Microsoft Yammer 是一款用于消息、会议和文件共享的企业协作工具。如果你是微软 Yammer 用户，你可以使用Amazon Kendra索引你的微软 Yammer 数据源。

你可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到你的 Microsoft Yammer 数据源。

要对 Amazon Kendra Microsoft Yammer 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

## 支持的功能
<a name="supported-features-yammer"></a>
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-yammer"></a>

在使用Amazon Kendra索引微软 Yammer 数据源之前，请在微软 Yammer 和AWS账户中进行这些更改。

**在 Microsoft Yammer 中，请确保：**
+ 已在 Office 365 中创建 Microsoft Yammer 管理账户。
+ 记下您的 Microsoft Yammer 用户名和密码。
+ 记下了您的 Microsoft 365 租户 ID。你可以在 Azure Active Directory 门户的属性或 OAuth 应用程序中找到你的租户 ID。
+ 在 Azure 门户中配置了 OAuth 应用程序，并记下了客户端 ID 和客户端密钥或客户端凭据。有关更多信息，请参阅 [Microsoft 教程](https://learn.microsoft.com/en-us/power-apps/developer/data-platform/walkthrough-register-app-azure-active-directory)和[注册应用程序示例](https://learn.microsoft.com/en-us/azure/healthcare-apis/register-application)。
**注意**  
当您在 Azure 门户中创建或注册应用程序时，密钥 ID 代表实际的密钥值。在创建密钥和应用程序时，您必须立即记下或保存该实际的密钥值。您可以通过在 Azure 门户中选择应用程序名称，然后导航到有关证书和密钥的菜单选项来访问您的密钥。  
您可以通过在 Azure 门户中选择应用程序名称，然后导航到概述页面来访问您的客户端 ID。其中的“应用程序（客户端）ID”即是客户端 ID。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 在 Microsoft Yammer 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Microsoft Yammer 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果你没有现有的IAM角色或密钥，则可以在将 Microsoft Yammer 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-yammer"></a>

Amazon Kendra要连接到你的 Microsoft Yammer 数据源，你必须提供微软 Yammer 数据源的必要细节，这样Amazon Kendra才能访问你的数据。如果你尚未为其配置 Microsoft YammerAmazon Kendra，请参阅[先决条件](#prerequisites-yammer)。

------
#### [ Console ]

**连接Amazon Kendra微软 Yammer** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Microsoft Yammer 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Microsoft Yammer 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **AWS Secrets Manager密钥** — 选择现有密钥或创建新Secrets Manager密钥来存储你的 Microsoft Yammer 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Microsoft Yammer-” 会自动添加到你的密钥名称中。

         1. 对于**用户名**、**密码** - 输入您的 Microsoft Yammer 用户名和密码。

         1. 对于**客户端 ID** 和**客户端密钥** - 输入您在 Azure 门户中从您的 Microsoft Yammer 账户生成的身份验证凭证值。

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **开始日期** - 指定开始在 Microsoft Yammer 中爬取数据的日期。

   1. **同步内容** - 选择要爬取的内容类型。例如，公共消息、私人消息和附件。

   1. **其他配置** - 指定要爬取的特定社区名称，并使用正则表达式模式来包含或排除某些内容。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API  ]

**连接Amazon Kendra微软 Yammer**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `YAMMER`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供密钥的亚马逊资源名称 (ARN)，该Secrets Manager密钥包含你的 Microsoft Yammer 账户的身份验证凭证。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "username": "user name",
      "password": "password",
      "clientId": "client ID",
      "clientSecret": "client secret"
  }
  ```
+ **IAM角色** —指定`RoleArn`何时调用`CreateDataSource`为IAM角色提供访问您的Secrets Manager密钥的权限，以及调用 Microsoft Yammer 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Microsoft Yammer 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅[配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **文档/内容类型** - 指定是否爬取社区内容、邮件和附件以及私人消息。
+ **包含和排除筛选条件** - 指定是包含还是排除某些内容。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Microsoft Yammer 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Microsoft Yammer 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-schema-yammer)。

------

## 了解详情
<a name="yammer-learn-more"></a>

要详细了解如何Amazon Kendra与 Microsoft Yammer 数据源集成，请参阅：
+ [宣布推出适用于 Yammer 的连接器 Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/announcing-the-yammer-connector-for-amazon-kendra/)

# MySQL
<a name="data-source-mysql"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 MySQL 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

MySQL 是一个开源的关系数据库管理系统。如果您是MySQL用户，则可以使用索Amazon Kendra引您的MySQL数据源。Amazon KendraMySQL数据源连接器支持 MySQL 8.0。21.

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的MySQL数据源。

要对Amazon KendraMySQL数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-mysql)
+ [先决条件](#prerequisites-mysql)
+ [连接说明](#data-source-procedure-mysql)
+ [注意](#mysql-notes)

## 支持的功能
<a name="supported-features-mysql"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-mysql"></a>

在使用索Amazon Kendra引MySQL数据源之前，请在MySQL和AWS帐户中进行这些更改。

**在 MySQL 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 在 MySQL 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 MySQL 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将MySQL数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-mysql"></a>

要Amazon Kendra连接到您的MySQL数据源，您必须提供MySQL凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，MySQL请参Amazon Kendra阅[先决条件](#prerequisites-mysql)。

------
#### [ Console ]

**要连接Amazon Kendra到 MySQL** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **MySQL 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **MySQL 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** - 输入数据库主机名。

   1.  **端口** - 输入数据库端口。

   1.  **实例** - 输入数据库实例。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的MySQL身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-MySQL-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + “用户 ** IDs” 列**-输入包含 IDs 要允许访问内容的用户的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（“文档” IDs、“**文档****标题**” 和 “**来源**” URLs）中进行选择，以映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 MySQL**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `mySql`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。MySQL密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用MySQL连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [MySQL S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 MySQL 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

------

## 注意
<a name="mysql-notes"></a>
+ Amazon Kendra检查已更新的内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Oracle Database
<a name="data-source-oracle-database"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Oracle Database 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来的集成，我们建议使用 Amazon Kendra 自定义连接器框架[1]，该框架可支持更广泛的企业使用案例，并具有更大的灵活性。

Oracle Database 是一个数据库管理系统。如果您是Oracle Database用户，则可以使用索Amazon Kendra引您的Oracle Database数据源。Amazon KendraOracle Database数据源连接器支持 Oracle 数据库 18c、19c 和 21c。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的Oracle Database数据源。

要对Amazon KendraOracle Database数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-oracle-database)
+ [先决条件](#prerequisites-oracle-database)
+ [连接说明](#data-source-procedure-oracle-database)
+ [注意](#oracle-database-notes)

## 支持的功能
<a name="supported-features-oracle-database"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-oracle-database"></a>

在使用索Amazon Kendra引Oracle Database数据源之前，请在Oracle Database和AWS帐户中进行这些更改。

**在 Oracle Database 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
最佳做法是提供Amazon Kendra只读数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 在 Oracle Database 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Oracle Database 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将Oracle Database数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-oracle-database"></a>

要Amazon Kendra连接到您的Oracle Database数据源，您必须提供Oracle Database凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，Oracle Database请参Amazon Kendra阅[先决条件](#prerequisites-oracle-database)。

------
#### [ Console ]

**要连接Amazon Kendra到 Oracle Database** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Oracle Database 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Oracle Database 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** - 输入数据库主机名。

   1.  **端口** - 输入数据库端口。

   1.  **实例** - 输入数据库实例。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的Oracle Database身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Oracle Database-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + **用户 IDs列**-输入包含允许用户访问内容 IDs 的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（**文档 IDs**、**文档标题**和**来源 URLs**）中选择要映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 Oracle Database**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `oracle`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。Oracle Database密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用Oracle Database连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [Oracle Database S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Oracle Database 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[Oracle Database 模板架构](ds-schemas.md#ds-oracle-database-schema)。

------

## 注意
<a name="oracle-database-notes"></a>
+ 在Amazon Kendra检查更新内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 最佳做法是提供Amazon Kendra只读数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# PostgreSQL
<a name="data-source-postgresql"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 PostgreSQL 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

PostgreSQL 是一个开源数据库管理系统。如果您是PostgreSQL用户，则可以使用索Amazon Kendra引您的PostgreSQL数据源。Amazon KendraPostgreSQL数据源连接器支持 PostgreSQL 9.6。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的PostgreSQL数据源。

要对Amazon KendraPostgreSQL数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-postgresql)
+ [先决条件](#prerequisites-postgresql)
+ [连接说明](#data-source-procedure-postgresql)
+ [注意](#postgresql-notes)

## 支持的功能
<a name="supported-features-postgresql"></a>
+ 字段映射
+ 用户上下文筛选
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-postgresql"></a>

在使用索Amazon Kendra引PostgreSQL数据源之前，请在PostgreSQL和AWS帐户中进行这些更改。

**在 PostgreSQL 中，请确保：**
+ 已记下您的数据库用户名和密码。
**重要**  
作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 已复制您的数据库主机 URL、端口和实例。
+ 在 PostgreSQL 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 PostgreSQL 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将PostgreSQL数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-postgresql"></a>

要Amazon Kendra连接到您的PostgreSQL数据源，您必须提供PostgreSQL凭据的详细信息，Amazon Kendra以便访问您的数据。如果您尚未进行配置，PostgreSQL请参Amazon Kendra阅[先决条件](#prerequisites-postgresql)。

------
#### [ Console ]

**要连接Amazon Kendra到 PostgreSQL** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **PostgreSQL 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **PostgreSQL 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. 在**源**中，输入以下信息：

   1.  **主机** - 输入数据库主机名。

   1.  **端口** - 输入数据库端口。

   1.  **实例** - 输入数据库实例。

   1. **启用 SSL 证书位置**-选择输入 SSL 证书文件的Amazon S3路径。

   1. 在**身份验证**中 - 请输入以下信息：

      1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的PostgreSQL身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

        1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

           1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-PostgreSQL-” 会自动添加到您的密钥名称中。

           1. 对于**数据库用户名**和**密码** - 输入您从数据库中复制的身份验证凭证值。

        1. 选择**保存**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 在**同步范围**中，从以下选项中进行选择：
      + **SQL 查询** - 输入 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
      + **主键列** - 提供数据库表的主键。这将标识数据库中的表。
      + **标题列** - 提供数据库表中文档标题列的名称。
      + **正文列** – 提供数据库表中文档正文列的名称。

   1. 在**其他配置 - *可选***中，从以下选项中选择以同步特定内容，而不是同步所有文件：
      + **变更检测列**-输入Amazon Kendra将用于检测内容变化的列的名称。 Amazon Kendra当其中任何一列发生变化时，将重新索引内容。
      + “用户 ** IDs” 列**-输入包含 IDs 要允许访问内容的用户的列的名称。
      + **组列** - 输入包含允许访问内容的群组的列的名称。
      + **源 URLs列**-输入包含要索引的源的列 URLs 的名称。
      + **时间戳列**-输入包含时间戳的列的名称。 Amazon Kendra使用时间戳信息来检测内容的变化并仅同步已更改的内容。
      + **时区列** - 输入列的名称，该列包含要搜索的内容的时区。
      + **时间戳格式** - 输入列的名称，该列包含用于检测内容更改和重新同步内容的时间戳格式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**中，对于**频率** - Amazon Kendra 与数据来源同步的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段（“文档” IDs、“**文档****标题**” 和 “**来源**” URLs）中进行选择，以映射到Amazon Kendra索引。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 PostgreSQL**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html)API 指定以下内容：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `JDBC`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **数据库类型** - 必须将数据库类型指定为 `postgresql`。
+ **SQL 查询** – 指定 SQL 查询语句，例如 SELECT 和 JOIN 操作。SQL 查询必须小于 32KB。Amazon Kendra 将爬取与您的查询相匹配的所有数据库内容。
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。PostgreSQL密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "user name": "database user name",
      "password": "password"
  }
  ```
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用PostgreSQL连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [PostgreSQL S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除过滤器**-您可以使用用户 IDs、群组、来源 URLs、时间戳和时区来指定是否包含特定内容。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 PostgreSQL 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅[PostgreSQL 模板架构](ds-schemas.md#ds-postgresql-schema)。

------

## 注意
<a name="postgresql-notes"></a>
+ Amazon Kendra检查已更新的内容时，不会跟踪已删除的数据库行。
+ 在数据库的一行中，字段名和值的大小不能超过 400KB。
+ 如果您的数据库数据源中有大量数据，并且不Amazon Kendra想在第一次同步后将所有数据库内容编入索引，则可以选择仅同步新的、修改过的或已删除的文档。
+ 作为最佳实践，请提供只读Amazon Kendra的数据库凭据。
+ 最佳做法是避免添加包含敏感数据或个人身份信息（PII）的表。

# Quip
<a name="data-source-quip"></a>

**注意**  
在 2026 年 5 月 31 日之前，仍可为现有客户提供对 Quip 连接器的完全支持。虽然此连接器不再可供新用户使用，但仍可供当前用户持续使用。我们正在持续优化我们的连接器产品组合，以提供更具可扩展性和可定制性的解决方案。对于未来集成，我们建议探索 Amazon Kendra 自定义连接器框架[1]，该框架旨在支持更广泛的企业使用案例，并且具备更大的灵活性。

Quip 是一款协作生产力软件，可提供实时文档创作功能。您可以使用Amazon Kendra索引 Quip 文件夹、文件、文件评论、聊天室和附件。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)和 [QuipConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QuipConfiguration.html)API 连接Amazon Kendra到 Quip 数据源。

要对 Amazon Kendra Quip 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-quip)
+ [先决条件](#prerequisites-quip)
+ [连接说明](#data-source-procedure-quip)
+ [了解详情](#quip-learn-more)

## 支持的功能
<a name="supported-features-quip"></a>

Amazon KendraQuip 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-quip"></a>

在使用Amazon Kendra索引 Quip 数据源之前，请在您的 Quip 和AWS帐户中进行这些更改。

**在 Quip 中，请确保：**
+ 拥有一个具有管理权限的 Quip 账户
+ 已创建包含个人访问令牌的 Quip 身份验证凭证。该令牌用作存储在AWS Secrets Manager密钥中的身份验证凭证。有关更多信息，请参阅[有关身份验证的 Quip 文档](https://quip.com/dev/admin/documentation/current#section/Authentication)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 已复制 Quip 站点域名。例如，域*https://quip-company.quipdomain.com/browse*在*quipdomain*哪里。
+ 在 Quip 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Quip 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Quip 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-quip"></a>

要连接Amazon Kendra到 Quip 数据源，您必须提供 Quip 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Quip 配置Amazon Kendra，请参阅[先决条件](#prerequisites-quip)。

------
#### [ Console ]

**连接Amazon Kendra到 Quip** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Quip 连接器**，然后选择**添加数据来源**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 ** 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Quip 域名** - 输入您从 Quip 账户中复制的域名。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 Quip 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Quip-” 会自动添加到您的密钥名称中。

         1. **Quip 令牌** - 输入在 Quip 中配置的个人访问令牌。

      1. 添加并保存您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **添加要抓取的 Quip 文件夹- IDs IDs 要抓取**的 Quip 文件夹。
**注意**  
要爬取根文件夹，包括其中的所有子文件夹和文档，请输入根文件夹 ID。要搜索特定的子文件夹，请添加特定的子文件夹。 IDs

   1. **其他配置（内容类型）**- 输入要爬取的内容类型。

   1. **正则表达式模式** - 包含或排除某些文件的正则表达式模式。最多可以添加 100 个模式。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 从生成的默认数据源字段中选择要映射到Amazon Kendra索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接Amazon Kendra到 Quip**

您必须使用 [QuipConfiguration ](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QuipConfiguration.html)API 指定以下内容：
+ **Quip 网站域**-例如，域名*https://quip-company.quipdomain.com/browse*在*quipdomain*哪里。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Quip 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "accessToken": "token"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及呼叫 Quip 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Quip 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+ **虚拟私有云（VPC）**- 在数据来源配置中指定 `VpcConfiguration`。请参阅[配置 Amazon Kendra 以使用 VPC](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html)。
+  **包含和排除筛选条件** - 指定是包含还是排除文件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **文件夹** - 指定要编制索引的 Quip 文件夹和子文件夹
**注意**  
要爬取根文件夹，包括其中的所有子文件夹和文档，请输入根文件夹 ID。要搜索特定的子文件夹，请添加特定的子文件夹。 IDs
+ **附件、聊天室、文件评论** - 选择是否包含对附件、聊天室内容和文件评论的爬取。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Quip 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

------

## 了解详情
<a name="quip-learn-more"></a>

要了解有关Amazon Kendra与 Quip 数据源集成的更多信息，请参阅：
+ [使用 Quip 连接器通过智能搜索在 Quip 文档中搜索知识 Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/search-for-knowledge-in-quip-documents-with-intelligent-search-using-the-quip-connector-for-amazon-kendra/)

# Salesforce
<a name="data-source-salesforce"></a>

Salesforce 是一款客户关系管理（CRM）工具，用于管理支持、销售和营销团队。您可以使用Amazon Kendra索引您的 Salesforce 标准对象，甚至是自定义对象。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)、API 或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Salesforce 数据源。[SalesforceConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SalesforceConfiguration.html)

Amazon Kendra有两个版本的 Salesforce 连接器。每个版本支持的功能包括：

**Salesforce 连接器 V1.0/API [SalesforceConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SalesforceConfiguration.html)**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件

**Salesforce 连接器 V2.0/API [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

**注意**  
Salesforce 连接器 V1.0/ SalesforceConfiguration API 于 2023 年结束。我们建议迁移到或使用 Salesforce 连接器 V2.0/ TemplateConfiguration API。

要对您的 Amazon Kendra Salesforce 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [Salesforce 连接器 V1.0](data-source-v1-salesforce.md)
+ [Salesforce 连接器 V2.0](data-source-v2-salesforce.md)

# Salesforce 连接器 V1.0
<a name="data-source-v1-salesforce"></a>

Salesforce 是一款客户关系管理（CRM）工具，用于管理支持、销售和营销团队。您可以使用Amazon Kendra索引您的 Salesforce 标准对象，甚至是自定义对象。

**重要**  
Amazon Kendra使用 Salesforce API 版本 48。Salesforce API 对每天可以发出的请求数量有限制。如果 Salesforce 超过了这些请求，它会重试，直到能够继续。

**注意**  
Salesforce 连接器 V1.0/ SalesforceConfiguration API 于 2023 年结束。我们建议迁移到或使用 Salesforce 连接器 V2.0/ TemplateConfiguration API。

要对您的 Amazon Kendra Salesforce 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v1-salesforce)
+ [先决条件](#prerequisites-v1-salesforce)
+ [连接说明](#data-source-procedure-v1-salesforce)

## 支持的功能
<a name="supported-features-v1-salesforce"></a>

Amazon KendraSalesforce 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件

## 先决条件
<a name="prerequisites-v1-salesforce"></a>

在使用Amazon Kendra索引您的 Salesforce 数据源之前，请在您的 Salesforce 和AWS账户中进行这些更改。

**在 Salesforce 中，请确保：**
+ 已创建一个 Salesforce 账户，并记下了用于连接 Salesforce 的用户名和密码。
+ 创建了一个已 OAuth 激活的 Salesforce 互联应用程序帐户，并已复制分配给您的 Salesforce 互联应用程序的使用者密钥（客户端 ID）和消费者机密（客户端密钥）。客户端 ID 和客户端密钥用作存储在密AWS Secrets Manager钥中的身份验证凭证。有关更多信息，请参阅[有关连接的应用程序的 Salesforce 文档](https://help.salesforce.com/s/articleView?id=sf.connected_app_overview.htm&type=5)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 已复制与用于连接 Salesforce 的账户关联的 Salesforce 安全令牌。
+ 要编制索引的 Salesforce 实例的 URL。通常为 *https://<company>.salesforce.com/*。服务器必须运行与 Salesforce 连接的应用程序。
+ 通过克隆 ReadOnly 个人资料，然后添加 “查看所有数据” 和 “管理文章” 权限，为拥有 Salesforce 只读访问权限的用户添加了凭据。这些凭据可以识别建立连接的用户以及连接到的 Salesforce Amazon Kendra 连接的应用程序。
+ 在 Salesforce 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Salesforce 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Salesforce 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v1-salesforce"></a>

Amazon Kendra要连接到您的 Salesforce 数据源，您必须提供您的 Salesforce 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Salesforce 进行配置，请参Amazon Kendra阅[先决条件](#prerequisites-v1-salesforce)。

------
#### [ Console ]

**连接到 Sales Amazon Kendra force** 

1. 登录AWS管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**入门**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Salesforce 连接器 V1.0**，然后选择**添加连接器**。

1. 在**指定数据来源详细信息**页面上输入以下信息：

   1. **数据源名称** - 输入您的数据源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**说明** - 为数据来源输入说明。

   1. **默认语言** - 用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在元数据中指定的语言会覆盖所选语言。

   1. **添加新标签** - 用于搜索和筛选资源或跟踪分摊费用的标签。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Salesforce URL** - 输入要编制索引的 Salesforce 站点的实例 URL。

   1. 对于**身份验证类型**，请选择**现有**或**新建**，以便存储您的 Salesforce 身份验证凭证。如果您选择创建新密钥，则会打开一个AWSSecrets Manager秘密窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

        1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Salesforce-” 会自动添加到您的密钥名称中。

        1. 对于**用户名**、**密码**、**安全令牌**、**使用者键**、**使用者密钥**和**身份验证 URL** - 输入您在 Salesforce 账户中创建的身份验证凭证值。

        1. 选择**保存身份验证**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 对于**爬取附件** - 选择爬取所有附加对象、文章和源。

   1. 对于**标准对象**、**知识文章**和**聊天源**，请选择要爬取的 Salesforce 实体或内容类型。
**注意**  
您必须提供配置信息，以便为至少一个标准对象、知识文章或聊天源编制索引。如果您选择爬取**知识文章**，则必须指定要编制索引的知识文章的类型、文章的名称，以及是为所有知识文章的标准字段编制索引，还是仅为自定义文章类型的字段编制索引。如果您选择为自定义文章编制索引，则必须指定文章类型的内部名称。最多可以指定 10 种文章类型。

   1. **频率**-与您的数据源同步的频率。Amazon Kendra

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 对于**标准知识文章**、**标准对象附件****和其他建议的字段映射**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。
**注意**  
映射到 `_document_body` 的索引是必需的。您无法更改 `Salesforce ID` 字段与 Amazon Kendra `_document_id ` 字段之间的映射。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接到 Sales Amazon Kendra force**

您必须指定以下 [SalesforceConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SalesforceConfiguration.html)API：
+ **服务器 URL** - 要编制索引的 Salesforce 站点的实例 URL。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Salesforce 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "authenticationUrl": "OAUTH endpoint that Amazon Kendra connects to get an OAUTH token",
      "consumerKey": "Application public key generated when you created your Salesforce application",
      "consumerSecret": "Application private key generated when you created your Salesforce application.",
      "password": "Password associated with the user logging in to the Salesforce instance",
      "securityToken": "Token associated with the user account logging in to the Salesforce instance",
      "username": "User name of the user logging in to the Salesforce instance"
  }
  ```
+ **IAM角色**-指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及呼叫 Salesforce 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Salesforce 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。
+ 您必须提供配置信息，以便为至少一个标准对象、知识文章或聊天源编制索引。
  + **标准对象** - 如果选择爬取**标准对象**，则必须指定标准对象的名称以及包含文档内容的标准对象表中字段的名称。
  + **知识文章** - 如果您选择爬取**知识文章**，则必须指定要编制索引的知识文章的类型、要编制索引的知识文章的状态，以及是为所有知识文章的标准字段编制索引，还是仅为自定义文章类型的字段编制索引。
  + **Chatter 提要**-如果您选择抓取 **Chatter 提要**，则必须在 Salesforce FeedItem 表中指定包含要索引的内容的列的名称。

您还可以添加以下可选功能：
+  **包含和排除筛选条件** - 指定是包含还是排除某些文件附件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **字段映射** - 选择将 Salesforce 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **用户上下文筛选和访问控制** – 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。

------

# Salesforce 连接器 V2.0
<a name="data-source-v2-salesforce"></a>

Salesforce 是一款客户关系管理（CRM）工具，用于管理支持、销售和营销团队。您可以使用Amazon Kendra索引您的 Salesforce 标准对象，甚至是自定义对象。

Amazon KendraSalesforce 数据源连接器支持以下 Salesforce 版本：开发者版和企业版。

**注意**  
Salesforce 连接器 V1.0/ SalesforceConfiguration API 于 2023 年结束。我们建议迁移到或使用 Salesforce 连接器 V2.0/ TemplateConfiguration API。

要对您的 Amazon Kendra Salesforce 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v2-salesforce)
+ [先决条件](#prerequisites-v2-salesforce)
+ [连接说明](#data-source-procedure-v2-salesforce)
+ [了解详情](#salesforce-v2-learn-more)
+ [注意](#salesforce-notes)

## 支持的功能
<a name="supported-features-v2-salesforce"></a>

Amazon KendraSalesforce 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v2-salesforce"></a>

在使用Amazon Kendra索引您的 Salesforce 数据源之前，请在您的 Salesforce 和AWS账户中进行这些更改。

**在 Salesforce 中，请确保：**
+ 已创建一个 Salesforce 管理账户，并记下了用于连接 Salesforce 的用户名和密码。
+ 已复制与用于连接 Salesforce 的账户关联的 Salesforce 安全令牌。
+ 创建了一个已 OAuth 激活的 Salesforce 互联应用程序帐户，并已复制分配给您的 Salesforce 互联应用程序的使用者密钥（客户端 ID）和消费者机密（客户端密钥）。客户端 ID 和客户端密钥用作存储在密AWS Secrets Manager钥中的身份验证凭证。有关更多信息，请参阅[有关连接的应用程序的 Salesforce 文档](https://help.salesforce.com/s/articleView?id=sf.connected_app_overview.htm&type=5)。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 要编制索引的 Salesforce 实例的 URL。通常为 *https://<company>.salesforce.com/*。服务器必须运行与 Salesforce 连接的应用程序。
+ 通过克隆 ReadOnly 个人资料，然后添加 “查看所有数据” 和 “管理文章” 权限，为拥有 Salesforce 只读访问权限的用户添加了凭据。这些凭据可以识别建立连接的用户以及连接到的 Salesforce Amazon Kendra 连接的应用程序。
+ 在 Salesforce 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Salesforce 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Salesforce 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v2-salesforce"></a>

Amazon Kendra要连接到您的 Salesforce 数据源，您必须提供您的 Salesforce 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Salesforce 进行配置，请参Amazon Kendra阅[先决条件](#prerequisites-v2-salesforce)。

------
#### [ Console ]

**要连接Amazon Kendra到 Salesforce，**请：

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Salesforce 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Salesforce 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Salesforce URL** - 输入要编制索引的 Salesforce 站点的实例 URL。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. 输入现有密钥，或者如果您创建了新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. **身份验证** — 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

        1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Salesforce-” 会自动添加到您的密钥名称中。

        1. 对于**用户名**、**密码**、**安全令牌**、**使用者键**、**使用者密钥**和**身份验证 URL** - 请输入您在 Salesforce 账户中生成和下载的身份验证凭证值。
**注意**  
如果您使用 Salesforce 开发者版，请使用`https://login.salesforce.com/services/oauth2/token`或 “我的域名” 登录网址（例如* https://MyCompany.my.salesforce.com*）作为**身份验证网址**。如果您使用 Salesforce 沙盒版，请使用`https://test.salesforce.com/services/oauth2/token `或 “我的域名” 登录网址（例如* MyDomainName--SandboxName.sandbox.my.salesforce.com*）作为**身份验证**网址。

        1. 选择**保存身份验证**。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 对于**爬取附件** - 选择爬取所有附加 Salesforce 对象。

   1. 对于**标准对象**、**带附件的标准对象**以及**不带附件的标准对象**和**知识文章** - 请选择要爬取的 Salesforce 实体或内容类型。

   1. 您必须提供配置信息，以便为至少一个标准对象、知识文章或聊天源编制索引。如果您选择爬取**知识文章**，则必须指定要编入索引的知识文章的类型。您可以选择已发布、已存档、草稿和附件。

      **正则表达式筛选条件** - 指定包含特定目录项的正则表达式模式。

1. 对于**附加配置**：
   + **ACL 信息** - 默认情况下包括所有访问控制列表。取消选择访问控制列表将公开该类别中的所有文件。
   + **正则表达式模式** - 添加包含或排除某些文件的正则表达式模式。最多可以添加 100 个模式。

   **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
   + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
   + 修改后的全新同步：每次数据源与索引同步时，仅为新增和修改过的内容编制索引。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
   + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. 对于**标准知识文章**、**标准对象附件****和其他建议的字段映射**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。
**注意**  
映射到 `_document_body` 的索引是必需的。您无法更改 `Salesforce ID` 字段与 Amazon Kendra `_document_id ` 字段之间的映射。您可以将任何 Salesforce 字段映射到文档标题或文档正文 Amazon reserved/default Kendra 索引字段。  
如果您将任意 Salesforce 字段映射到 Amazon Kendra 的文档标题和正文字段，Amazon Kendra 将在搜索结果中使用来自这些标题和正文字段的数据。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接到 Sales Amazon Kendra force**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `SALESFORCEV2`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **主机 URL** - 指定 Salesforce 实例的主机 URL。
+ **同步模式** – 指定当数据来源内容发生变化时 Amazon Kendra 更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`每次数据源与索引同步时，仅对新的、修改过的和已删除的内容编制索引。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
  + `CHANGE_LOG`每次数据源与索引同步时，仅索引新的和修改过的内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Salesforce 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "authenticationUrl": "OAUTH endpoint that Amazon Kendra connects to get an OAUTH token",
      "consumerKey": "Application public key generated when you created your Salesforce application",
      "consumerSecret": "Application private key generated when you created your Salesforce application",
      "password": "Password associated with the user logging in to the Salesforce instance",
      "securityToken": "Token associated with the user account logging in to the Salesforce instance",
      "username": "User name of the user logging in to the Salesforce instance"
  }
  ```
+ **IAM角色**-指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及呼叫 Salesforce 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Salesforce 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **包含和排除筛选条件** - 您可以指定是包含还是排除某些文档、账户、活动、案例、联系人、潜在客户、机会、解决方案、任务、群组、聊天者和自定义实体文件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 Salesforce 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
**注意**  
映射到 `_document_body` 的索引是必需的。您无法更改 `Salesforce ID` 字段与 Amazon Kendra `_document_id ` 字段之间的映射。您可以将任何 Salesforce 字段映射到文档标题或文档正文 Amazon reserved/default Kendra 索引字段。  
如果您将任意 Salesforce 字段映射到 Amazon Kendra 的文档标题和正文字段，Amazon Kendra 将在搜索结果中使用来自这些标题和正文字段的数据。

有关要配置的其他重要 JSON 键的列表，请参阅 [Salesforce 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-salesforce-schema)。

------

## 了解详情
<a name="salesforce-v2-learn-more"></a>

要了解有关Amazon Kendra与您的 Salesforce 数据源集成的更多信息，请参阅：
+ [宣布更新了 Salesforce 连接器 (V2) Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/announcing-the-updated-salesforce-connector-v2-for-amazon-kendra/)

## 注意
<a name="salesforce-notes"></a>
+ 启用访问控制列表 (ACLs) 后，由于 Salesforce API 的限制，“仅同步新内容或修改过的内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。

# ServiceNow
<a name="data-source-servicenow"></a>

ServiceNow 提供基于云的服务管理系统，用于创建和管理组织级工作流程，例如 IT 服务、票务系统和支持。您可以使用索Amazon Kendra引您的 ServiceNow 目录、知识文章、事件及其附件。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)、API 或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API 连接到Amazon Kendra您的 ServiceNow 数据源。[ServiceNowConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ServiceNowConfiguration.html)

Amazon Kendra有两个版本的 ServiceNow 连接器。每个版本支持的功能包括：

**ServiceNow 连接器 V1.0/API [ServiceNowConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ServiceNowConfiguration.html)**
+ 字段映射
+ ServiceNow 实例版本：伦敦，其他
+ 包含/排除筛选条件

**ServiceNow 连接器 V2.0/API [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)**
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ ServiceNow 实例版本：罗马、圣地亚哥、东京、其他
+ 虚拟私有云（VPC）

**注意**  
ServiceNow 连接器 V1.0/ ServiceNowConfiguration API 于 2023 年结束。我们建议迁移到或使用 ServiceNow 连接器 V2.0/ TemplateConfiguration API。

要对Amazon KendraServiceNow 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [ServiceNow 连接器 V1.0](data-source-v1-servicenow.md)
+ [ServiceNow 连接器 V2.0](data-source-v2-servicenow.md)
+ [使用查询指定要编制索引的文档](servicenow-query.md)

# ServiceNow 连接器 V1.0
<a name="data-source-v1-servicenow"></a>

ServiceNow 提供基于云的服务管理系统，用于创建和管理组织级工作流程，例如 IT 服务、票务系统和支持。您可以使用索Amazon Kendra引您的 ServiceNow 目录、知识文章及其附件。

**注意**  
ServiceNow 连接器 V1.0/ ServiceNowConfiguration API 于 2023 年结束。我们建议迁移到或使用 ServiceNow 连接器 V2.0/ TemplateConfiguration API。

要对Amazon KendraServiceNow 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v1-servicenow)
+ [先决条件](#prerequisites-v1-servicenow)
+ [连接说明](#data-source-procedure-v1-servicenow)
+ [了解详情](#servicenow-v1-learn-more)

## 支持的功能
<a name="supported-features-v1-servicenow"></a>

Amazon KendraServiceNow 数据源连接器支持以下功能：
+ ServiceNow 实例版本：伦敦，其他
+ 包含/排除模式：服务目录、知识文章及其附件

## 先决条件
<a name="prerequisites-v1-servicenow"></a>

在使用索Amazon Kendra引 ServiceNow 数据源之前，请在 ServiceNow 和AWS帐户中进行这些更改。

**在 ServiceNow，请确保你有：**
+ 已创建 ServiceNow 管理员账户并创建 ServiceNow实例。
+ 已复制您的 ServiceNow 实例 URL 的主机。例如，如果实例的 URL 是*https://your-domain.service-now.com*，则您输入的主机 URL 的格式为*your-domain.service-now.com*。
+ 已记下您的基本身份验证凭证，其中包含允许Amazon Kendra连接到您的 ServiceNow 实例的用户名和密码。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **可选：**配置了 OAuth 2.0 凭据令牌，该令牌可以识别Amazon Kendra和生成用户名、密码、客户端 ID 和客户机密钥。用户名和密码必须提供对 ServiceNow 知识库和服务目录的访问权限。有关更多信息[，请参阅有关 OAuth 2.0 身份验证的ServiceNow 文档](https://www.servicenow.com/docs/bundle/utah-platform-security/page/integrate/single-sign-on/concept/c_Authentication.html)。
+ 添加了以下权限：
  + kb\$1category
  + kb\$1knowledge
  + kb\$1knowledge\$1base
  + kb\$1uc\$1cannot\$1read\$1mtom
  + kb\$1uc\$1can\$1read\$1mtom
  + sc\$1catalog
  + sc\$1category
  + sc\$1cat\$1item
  + sys\$1attachment
  + sys\$1attachment\$1doc
  + sys\$1user\$1role
+ 已选中每个文档在您计划用于同一索引的其他数据源中 ServiceNow 以及其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 ServiceNow 身份验证凭证存储在AWS Secrets Manager密钥中，如果使用 API，请记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 ServiceNow 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v1-servicenow"></a>

要Amazon Kendra连接到您的 ServiceNow 数据源，您必须提供 ServiceNow 数据源的必要详细信息，以便Amazon Kendra能够访问您的数据。如果您尚未进行配置， ServiceNow 请参Amazon Kendra阅[先决条件](#prerequisites-v1-servicenow)。

------
#### [ Console ]

**要连接Amazon Kendra到 ServiceNow** 

1. 登录AWS管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据源**页面上，选择**ServiceNow连接器 V1.0**，然后选择**添加数据源**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **ServiceNow 主机** —输入 ServiceNow主机 URL。

   1. **ServiceNow 版本**-选择您的 ServiceNow 版本。

   1. 根据您的使用案例，选择**基本身份验证**或 **Oauth 2.0 身份验证**。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 ServiceNow 身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-ServiceNow-” 会自动添加到您的密钥名称中。

      1. 如果使用基本身份验证，请输入您帐户的**密码名称**、**用户名**和**密码**。 ServiceNow 

         如果使用 OAuth2 身份验证，请输入您在账户中创建的**密钥名称**、**用户名**、**密码**、客户端 **ID** 和**客户端密钥**。 ServiceNow 

      1. 选择**保存和添加密钥**。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **包含知识文章** - 选择为知识文章编制索引。

   1. **知识文章的类型**-根据您的用例，在 “**仅包含公开文章****” 和 “基于 ServiceNow 筛选查询**包含文章” 之间进行选择。如果您选择 “**包含基于 ServiceNow 筛选查询的文章**”，则必须输入从您的 ServiceNow账户中复制的**筛选查询**。

   1. **包含知识文章附件** - 选择为知识文章附件编制索引。您也可以选择要编制索引的特定文件类型。

   1. **包含目录项** - 选择为目录项编制索引。

   1. **包含目录项附件** - 选择为目录项附件编制索引。您也可以选择要编制索引的特定文件类型。

   1. **频率**-与您的数据源同步的频率。Amazon Kendra

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **知识文章**和**服务目录**-从Amazon Kendra生成的默认数据源字段以及要映射到索引的其他建议字段映射中进行选择。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 ServiceNow**

必须使用 [ServiceNowConfiguration API](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ServiceNowConfiguration.html) 指定以下内容：
+ **数据源 URL**-指定 ServiceNow URL。主机端点应如下所示:*your-domain.service-now.com*.
+ **数据源主机实例**-将 ServiceNow 主机实例版本指定为`LONDON`或`OTHERS`。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。 ServiceNow 

   如果您使用基本身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "username": "user name",
      "password": "password"
  }
  ```

  如果您使用 OAuth2 身份验证，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "username": "user name",
      "password": "password",
      "clientId": "client id",
      "clientSecret": "client secret"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用 ServiceNow 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [ ServiceNow S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **字段映射** - 选择将 ServiceNow 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。
+  **包含和排除筛选条件** - 指定是包含还是排除某些类别和知识文章的附件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+ **索引参数** - 您也可以选择指定是否：
  + 为知识文章或服务目录编制索引，或者为两者同时编制索引。如果您选择为知识文章和服务目录项编制索引，则必须提供映射到索引中索引文档内容字段的Amazon Kendra字段名称。 ServiceNow 
  + 为知识文章和目录项的附件编制索引。
  + 使用从一个或多个知识库中选择文档的 ServiceNow 查询。知识库可以是公有的，也可以是私有的。有关更多信息，请参阅[使用查询指定要编制索引的文档](https://docs.aws.amazon.com/kendra/latest/dg/servicenow-query.html)。

------

## 了解详情
<a name="servicenow-v1-learn-more"></a>

要了解有关Amazon Kendra与 ServiceNow 数据源集成的更多信息，请参阅：
+ [Amazon KendraServiceNow 在线连接器入门](https://aws.amazon.com/blogs/machine-learning/getting-started-with-amazon-kendra-servicenow-online-connector/)

# ServiceNow 连接器 V2.0
<a name="data-source-v2-servicenow"></a>

ServiceNow 提供基于云的服务管理系统，用于创建和管理组织级工作流程，例如 IT 服务、票务系统和支持。您可以使用索Amazon Kendra引您的 ServiceNow 目录、知识文章、事件及其附件。

要对Amazon KendraServiceNow 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-v2-servicenow)
+ [先决条件](#prerequisites-v2-servicenow)
+ [连接说明](#data-source-procedure-v2-servicenow)
+ [了解详情](#servicenow-learn-more)

## 支持的功能
<a name="supported-features-v2-servicenow"></a>

Amazon KendraServiceNow 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ ServiceNow 实例版本：罗马、圣地亚哥、东京、其他
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-v2-servicenow"></a>

在使用索Amazon Kendra引 ServiceNow 数据源之前，请在 ServiceNow 和AWS帐户中进行这些更改。

**在 ServiceNow，请确保你有：**
+ 创建了个人或企业开发者实例，并拥有一个具有管理角色的 ServiceNow 实例。
+ 已复制您的 ServiceNow 实例 URL 的主机。您输入的主机 URL 的格式为*your-domain.service-now.com*。您需要 ServiceNow 实例 URL 才能连接到 Amazon Kendra。
+ 记下了您的基本身份验证凭证，包括用户名和密码，Amazon Kendra以允许您连接到您的 ServiceNow 实例。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **可选：**已配置 OAuth 2.0 客户端凭证，这些凭据可以使用用户名、密码和生成的客户端 ID 以及客户端密钥进行识别Amazon Kendra。有关更多信息[，请参阅有关 OAuth 2.0 身份验证的ServiceNow 文档](https://www.servicenow.com/docs/bundle/utah-platform-security/page/integrate/single-sign-on/concept/c_Authentication.html)。
+ 添加了以下权限：
  + kb\$1category
  + kb\$1knowledge
  + kb\$1knowledge\$1base
  + kb\$1uc\$1cannot\$1read\$1mtom
  + kb\$1uc\$1can\$1read\$1mtom
  + sc\$1catalog
  + sc\$1category
  + sc\$1cat\$1item
  + sys\$1attachment
  + sys\$1attachment\$1doc
  + sys\$1user\$1role
+ 已选中每个文档在您计划用于同一索引的其他数据源中 ServiceNow 以及其他数据源中都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 ServiceNow 身份验证凭证存储在AWS Secrets Manager密钥中，如果使用 API，请记下该密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 ServiceNow 数据源连接到时使用控制台创建新的IAM角色和Secrets Manager密钥Amazon Kendra。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-v2-servicenow"></a>

要Amazon Kendra连接到您的 ServiceNow 数据源，您必须提供 ServiceNow 数据源的必要详细信息，以便Amazon Kendra能够访问您的数据。如果您尚未进行配置， ServiceNow 请参Amazon Kendra阅[先决条件](#prerequisites-v2-servicenow)。

------
#### [ Console ]

**要连接Amazon Kendra到 ServiceNow** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **ServiceNow 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **ServiceNow 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **ServiceNow 主机** —输入 ServiceNow主机 URL。您输入的主机 URL 的格式为*your-domain.service-now.com*。

   1. **ServiceNow 版本**-选择您的 ServiceNow 实例版本。您可以选择“罗马”、“圣地亚哥”、“东京”或“其他”。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. **身份验证** – 选择**基本身份验证**或 **OAuth 2.0 身份验证**。

   1. AWSSecrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 ServiceNow 身份验证凭证。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。在窗口中输入以下信息：

      1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-ServiceNow-” 会自动添加到您的密钥名称中。

      1. 如果使用基本身份验证，请输入您帐户的**密码名称**、**用户名**和**密码**。 ServiceNow 

         如果使用 OAuth2 .0 Authentication，请输入您在账户中创建的**密钥名称**、**用户名**、**密码**、客户端 **ID** 和**客户端密钥**。 ServiceNow 

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAMro** le —选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. 对于**知识文章**，请选择以下选项：
      +  **知识文章** - 选择为知识文章编制索引。
      + **知识文章附件** - 选择为知识文章附件编制索引。
      + **知识文章的类型**-根据您的用例，**根据 ServiceNow 筛选查询，在 “**仅限公开文章**” 和 “知识文章**” 之间进行选择。如果您选择 “**包含基于 ServiceNow 筛选查询的文章**”，则必须输入从您的 ServiceNow账户中复制的**筛选查询**。筛选器查询示例包括：*workflow\$1state=draft^EQ*、*kb\$1knowledge\$1base=dfc19531bf2021003f07e2c1ac0739ab^text ISNOTEMPTY^EQ*、*article\$1type=text^active=true^EQ*。
**重要**  
如果您选择**仅抓取公开文章，则仅**Amazon Kendra抓取中分配了公共访问角色的知识文章。 ServiceNow
      + **基于简短描述筛选条件包含文章** - 指定正则表达式模式以包含或排除特定文章。

   1. 对于**服务目录项**：
      +  **服务目录项** - 选择为目录项编制索引。
      + **服务目录项附件** - 选择为服务目录项附件编制索引。
      + **活动服务目录项** - 选择为活动目录项编制索引。
      + **非活动服务目录项** - 选择为非活动目录项编制索引。
      + **筛选查询**-根据您的 ServiceNow 实例中定义的筛选器选择包含服务目录项目。过滤器查询示例包括：*short\$1descriptionLIKEAccess^category=2809952237b1300054b6a3549dbe5dd4^EQ*、*nameSTARTSWITHService^active=true^EQ*。
      + **根据简短描述筛选条件包含服务目录项** - 指定正则表达式模式以包括特定的目录项。

   1. 对于**事件**：
      + **事件** - 选择为服务事件编制索引。
      + **事件附件** - 选择为事件附件编制索引。
      + **活动事件** - 选择为活动事件编制索引。
      + **非活动事件** - 选择为非活动事件编制索引。
      + **活动事件类型** -根据您的使用案例，选择**所有事件**、**未解决的事件**、**未解决 - 未分配的事件**或**已解决的事件**。
      + **筛选查询**-根据您的 ServiceNow 实例中定义的筛选器选择包含事件。过滤器查询示例包括：*short\$1descriptionLIKETest^urgency=3^state=1^EQ*、*priority=2^category=software^EQ *。
      + **根据简短描述筛选条件包含事件** - 指定包含特定事件的正则表达式模式。

   1. 对于**其他配置**：
      + **ACL 信息** - 默认情况下，包含所选实体的访问控制列表。取消选择访问控制列表将公开该类别中的所有文件。对于未选择的实体，ACL 选项会自动停用。对于公开文章，ACL 不适用。
      + 对于**最大文件大小** — 指定 Amazon Kendra 将抓取的文件大小限制。 MBs Amazon Kendra 将仅爬取您定义的大小限制范围内的文件。默认文件大小为 50 MB。最大文件大小应大于 0 MB 且小于或等于 50 MB。
      + **附件正则表达式模式** - 添加正则表达式模式以包含或排除目录、知识文章和事件的某些附加文件。最多可以添加 100 个模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认字段映射**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**要连接Amazon Kendra到 ServiceNow**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `SERVICENOWV2`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **主机 URL**-指定 ServiceNow 主机实例版本。例如 *your-domain.service-now.com*。
+ **身份验证类型**-指定您使用的身份验证类型，无论是`OAuth2`针对您的 ServiceNow 实例`basicAuth`还是针对您的实例。
+ **ServiceNow 实例版本**-指定您使用的 ServiceNow 实例，是`Tokyo`、`Sandiego``Rome`、或`Others`。
+ **同步模式** – 指定当数据来源内容发生变化时 Amazon Kendra 更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`每次数据源与索引同步时，仅对新的、修改过的和已删除的内容编制索引。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您在账户中创建的身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。 ServiceNow 

  如果您使用基本身份验证，密钥将存储在 JSON 结构中，其中包含以下键：

  ```
  {
      "username": "user name",
      "password": "password"
  }
  ```
+ 如果您使用 OAuth2 客户端证书，则密钥将存储在 JSON 结构中，其中包含以下密钥：

  ```
  {
      "username": "user name",
      "password": "password",
      "clientId": "client id",
      "clientSecret": "client secret"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用 ServiceNow 连接器 APIs 所需的公众的权限，以及Amazon Kendra。有关更多信息，请参阅 [ ServiceNow S3 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **包含和排除筛选条件** - 您可以使用知识文章、服务目录和事件的文件名和文件类型来指定是包含还是排除某些附件。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **要索引的特定文档**-您可以使用 ServiceNow 查询从一个或多个知识库（包括私有知识库）中指定所需的文档。对知识库的访问权限由您用来连接 ServiceNow 实例的用户决定。有关更多信息，请参阅[使用查询指定要编制索引的文档](https://docs.aws.amazon.com//kendra/latest/dg/servicenow-query.html)。
+ **索引参数** - 您也可以选择指定是否：
  + 为知识文章、服务目录或事件编制索引，或者为所有这些内容编制索引。如果您选择为知识文章、服务目录项目和事件编制索引，则必须提供映射到索引中索引文档内容字段的Amazon Kendra字段名称。 ServiceNow 
  + 为知识文章、服务目录项和事件的附件编制索引。
  + 根据 `short description` 筛选模式包含知识文章、服务目录项目和事件。
  + 选择筛选活动和非活动服务目录项目和事件。
  + 选择根据事件类型筛选事件。
  + 选择爬取对哪些实体的 ACL。
  + 您可以使用 ServiceNow 查询从一个或多个知识库（包括私有知识库）中指定所需的文档。对知识库的访问权限由您用来连接 ServiceNow实例的用户决定。有关更多信息，请参阅[使用查询指定要编制索引的文档](https://docs.aws.amazon.com//kendra/latest/dg/servicenow-query.html)。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+  **字段映射** - 选择将 ServiceNow 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [ServiceNow 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-servicenow-schema)。

------

## 了解详情
<a name="servicenow-learn-more"></a>

要了解有关Amazon Kendra与 ServiceNow 数据源集成的更多信息，请参阅：
+ [开始Amazon Kendra发布更新的 ServiceNow 连接器 (V2) Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/announcing-the-updated-servicenow-connector-v2-for-amazon-kendra/)

# 使用查询指定要编制索引的文档
<a name="servicenow-query"></a>

您可以使用 ServiceNow 查询来指定要包含在Amazon Kendra索引中的文档。使用查询时，您可以指定多个知识库，包括私有知识库。对知识库的访问权限由您用来连接 ServiceNow 实例的用户决定。

要生成查询，请使用 ServiceNow 查询生成器。您可以使用构建器来创建查询并测试查询是否可以返回正确的文档列表。

**使用 ServiceNow 控制台创建查询**

1. 登录 ServiceNow 控制台。

1. 从左侧菜单中选择**知识**，再选择**文章**，然后选择**全部**。

1. 在页面顶部选择筛选条件图标。

1. 使用查询构建器创建查询。

1. 查询完成后，右键单击该查询，然后选择**复制查询**，以便从查询构建器中复制查询。保存此查询以在中使用Amazon Kendra。  
![\[Query builder interface showing Knowledge base filters with options to run, save, and copy query.\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/images/ServiceNowQuery.png)

在复制查询时，确保不要更改任何查询参数。如果无法识别任何查询参数，则 ServiceNow 会将该参数视为空且不使用它来筛选结果。

# Slack
<a name="data-source-slack"></a>

Slack 是一款企业通信应用程序，允许用户通过各种公共和私人频道发送消息和附件。您可以使用Amazon Kendra索引您的 Slack 公共和私人频道、机器人和存档消息、文件和附件、直接消息和群组消息。还可以选择要筛选的特定内容。

**注意**  
Amazon Kendra现在支持升级后的 Slack 连接器。  
已为您自动完成控制台升级。您在控制台中新建的所有连接器都将使用升级后的架构。现在，如果您使用 API，则必须使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) 对象而不是 `SlackConfiguration` 对象来配置您的连接器。  
使用旧版控制台和 API 架构配置的连接器仍可照常运行，但您将无法编辑或更新它们。如果要编辑或更新连接器配置，必须新建一个连接器。  
我们建议您将连接器工作流程迁移至升级后的版本。使用旧版架构配置的连接器的支持预计将在 2024 年 6 月前终止。

您可以使用[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)或 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Slack 数据源。

要对 Amazon Kendra Slack 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-slack)
+ [先决条件](#prerequisites-slack)
+ [连接说明](#data-source-procedure-slack)
+ [了解详情](#slack-learn-more)

## 支持的功能
<a name="supported-features-slack"></a>

Amazon KendraSlack 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-slack"></a>

在使用Amazon Kendra索引 Slack 数据源之前，请在您的 Slack 和AWS帐户中进行这些更改。

**在 Slack 中，请确保：**
+ 已配置 Slack 机器人用户 OAuth 令牌或 Slack 用户 OAuth 令牌。您可以选择任一令牌Amazon Kendra来连接您的 Slack 数据源。需要使用令牌作为您的身份验证凭证。有关更多信息，请参阅[有关访问令牌的 Slack 文档](https://api.slack.com/authentication/token-types)。
**注意**  
如果您使用机器人令牌作为 Slack 凭证的一部分，则无法将私信和群组消息编入索引，必须将机器人令牌添加到要编制索引的频道中。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ 在 Slack 工作区主页 URL 中记下您的 Slack 工作区团队 ID。例如，团队 ID *https://app.slack.com/client/T0123456789/... * 在*T0123456789*哪里。
+ 添加了以下 Oauth 范围/权限：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/data-source-slack.html)
+ 在 Slack 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Slack 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Slack 数据源连接至时使用控制台创建新的IAM角色和Secrets Manager密钥。Amazon Kendra如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-slack"></a>

要Amazon Kendra连接到您的 Slack 数据源，您必须提供 Slack 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Slack 配置Amazon Kendra，请参阅[先决条件](#prerequisites-slack)。

------
#### [ Console ]

**连接Amazon Kendra到 Slack** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Slack 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Slack 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Slack 工作区团队 ID** - 您的 Slack 工作区的团队 ID。可以在 Slack 工作区主页的 URL 中找到您的团队 ID。例如，团队 ID *https://app.slack.com/client/T0123456789/...* 在*T0123456789*哪里。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 Slack 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 在**创建 AWS Secrets Manager 密钥窗口**中输入以下信息：

         1. **密钥名称** - 密钥的名称。前缀 “AmazonKendra-Slack-” 会自动添加到您的密钥名称中。

         1. 对于 **Slack 令牌** - 输入您在 Slack 中配置的身份验证凭证值。

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **选择内容的类型** - 选择要爬取的 Slack 实体或内容类型。您可以选择 All channels（所有通道）、Public channels（公有通道）、Private channels（私有通道）、Group messages（群组消息）和 Private messages（私人消息）。

   1. **选择爬取开始日期** - 输入您想要开始爬取内容的日期。

   1. 对于**其他配置** - 选择是否包含机器人消息和已归档消息，并可使用正则表达式模式来包含或排除特定内容。
**注意**  
如果您选择同时包含频道 IDs 和频道名称，Amazon KendraSlack 连接器将优先考虑频道 IDs 而不是频道名称。  
如果您选择包含特定的私人和群组消息，Amazon Kendra Slack 连接器将忽略所有其他私人和群组消息，仅爬取您指定的私人和群组消息。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 – 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接Amazon Kendra到 Slack**

您必须使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-schema-slack)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `SLACK`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **Slack 工作区团队 ID** - 您从 Slack 主页 URL 中复制的 Slack 团队 ID。
+ **开始日期** - 开始从 Slack 工作区团队爬取数据的日期。日期必须遵循此格式: yyyy-mm-dd.
+ **同步模式**-指定数据源内容发生变化时Amazon Kendra应如何更新索引。首次将数据来源与 Amazon Kendra 同步时，默认情况下会爬取所有内容并编制索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。您可以选择：
  + `FORCED_FULL_CRAWL`，每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
  + `FULL_CRAWL`，每次数据来源与索引同步时，仅为新增、修改和删除的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
  + `CHANGE_LOG`，每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
+ **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Slack 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "slackToken": "token"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`以向IAM角色提供访问您的Secrets Manager密钥的权限以及调用 Slack 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Slack 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+ **特定通道** - 按公有通道或私有通道筛选，并按通道 ID 指定特定通道。
+ **通道和消息类型** -Amazon Kendra 是否应为您的公有和私有通道、您的群组和私人消息以及您的机器人和存档消息编制索引。如果您使用机器人令牌作为 Slack 身份验证凭证的一部分，则必须将机器人令牌添加到要编制索引的频道。您无法使用机器人令牌将私信和群组消息编入索引。
+ **回溯** - 您可以选择配置 `lookBack` 参数，以使 Slack 连接器能够爬取在上次连接器同步前指定小时数内更新或删除的内容。
+  **包含和排除筛选条件** - 指定是包含还是排除某些 Slack 内容。如果您使用机器人令牌作为 Slack 身份验证凭证的一部分，则必须将机器人令牌添加到要编制索引的频道。您无法使用机器人令牌将私信和群组消息编入索引。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **字段映射** - 选择将 Slack 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [Slack 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-schema-slack)。

------

## 了解详情
<a name="slack-learn-more"></a>

要了解有关Amazon Kendra与 Slack 数据源集成的更多信息，请参阅：
+ [使用 Amazon Kendra Slack 连接器进行智能搜索，揭开 Slack 工作区的面纱](https://aws.amazon.com/blogs/machine-learning/unravel-the-knowledge-in-slack-workspaces-with-intelligent-search-using-the-amazon-kendra-slack-connector/)

# Zendesk
<a name="data-source-zendesk"></a>

Zendesk 是一个客户关系管理系统，可帮助企业自动化和增强客户支持互动。您可以使用Amazon Kendra索引您的 Zendesk 支持工单、工单评论、工单附件、帮助中心文章、文章评论、文章评论附件、指南社区主题、社区帖子和社区帖子评论。

如果要仅对位于特定组织内的工单编制索引，则可以按组织名称进行筛选。您也可以选择为您想要开始从 Zendesk 爬取数据的时间设置一个爬取日期。

您可以使用[Amazon Kendra控制](https://console.aws.amazon.com/kendra/)台和 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)API Amazon Kendra 连接到您的 Zendesk 数据源。

要对 Amazon Kendra Zendesk 数据源连接器进行故障排除，请参阅[数据来源故障排除](troubleshooting-data-sources.md)。

**Topics**
+ [支持的功能](#supported-features-zendesk)
+ [先决条件](#prerequisites-zendesk)
+ [连接说明](#data-source-procedure-zendesk)
+ [了解详情](#zendesk-learn-more)
+ [注意](#zendesk-notes)

## 支持的功能
<a name="supported-features-zendesk"></a>

Amazon KendraZendesk 数据源连接器支持以下功能：
+ 字段映射
+ 用户访问控制
+ 包含/排除筛选条件
+ 更改日志、完整和增量内容同步
+ 虚拟私有云（VPC）

## 先决条件
<a name="prerequisites-zendesk"></a>

在使用Amazon Kendra索引 Zendesk 数据源之前，请在您的 Zendesk 和AWS账户中进行这些更改。

**在 Zendesk 中，请确保：**
+ 已创建 Zendesk 套件（专业版/企业版）管理账户。
+ 已记下您的 Zendesk 主机 URL。例如 *https://\$1sub-domain\$1.zendesk.com/*。
**注意**  
（本地/服务器）Amazon Kendra会检查中AWS Secrets Manager包含的端点信息是否与数据源配置详细信息中指定的端点信息相同。这有助于防止出现[混淆代理人问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)，这是一个安全问题，即用户无权执行操作，但可以将 Amazon Kendra 作为代理来访问配置的密钥和执行操作。如果以后更改端点信息，则必须创建一个新密钥来同步此信息。
+ 使用授权码授权流程设置 OAuth 2.0 身份验证：

  1. 在管理中心中，导航到应用程序和集成 > APIs > Zendesk API。

  1. 选择 “ OAuth 客户端” 选项卡，然后单击 “添加 OAuth 客户端”。

  1. 配置 OAuth 客户端详细信息：设置客户机名称和描述，将客户端类型设置为 “机密”，添加相应的重定向 URLs （例如，https://localhost/callback 用于测试），保存并安全地存储生成的客户端 ID 和客户端密钥。

  1.  确保 OAuth 客户端具有所需的 “读取” 范围（如果您需要写入权限，则为 “读写”）。

  1.  使用授权码授予流程生成访问令牌：
     + 在浏览器中，导航到：`https://{subdomain}.zendesk.com/oauth/authorizations/new?response_type=code&client_id={your_client_id}&redirect_uri={your_redirect_uri}&scope=read`
     +  按提示进行身份验证并授权应用程序。
     +  授权后，Zendesk 会使用代码参数（例如授权码）重定向到 redirect\$1uri。 https://localhost/callback?code=\$1authorization\$1code\$1). Copy
     +  通过向 Zendesk 的令牌端点发送 POST 请求，将授权码换成访问令牌：

       ```
       curl -X POST https://{subdomain}.zendesk.com/oauth/tokens \
         -H "Content-Type: application/x-www-form-urlencoded" \
         -d "grant_type=authorization_code&code={authorization_code}&client_id={your_client_id}&client_secret={your_client_secret}&redirect_uri={your_redirect_uri}&scope=read"
       ```
     +  Zendesk 会返回一个包含 access\$1token 的 JSON 对象。提取并安全地存储此访问令牌。

  1. 请妥善存储生成的访问令牌。此访问令牌将用于 Kendra 集成。
+ 
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。
+ **可选：**已安装允许 Amazon Kendra 进行连接的 SSL 证书。
+ 在 Zendesk 以及计划用于编制同一索引的其他数据来源中，已检查每个文档都是唯一的。您要用于编制索引的每个数据来源在所有数据来源中都不能包含相同的文档。文档对索引来说 IDs 是全局的，并且每个索引必须是唯一的。

**在你的AWS 账户，请确保你有：**
+ [已创建Amazon Kendra索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)，如果使用 API，则记下索引 ID。
+ 为您的数据源@@ [创建了一个IAM角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)，如果使用 API，请记下该角色的 ARN。IAM
**注意**  
如果您更改了身份验证类型和证书，则必须更新您的IAM角色才能访问正确的AWS Secrets Manager密钥 ID。
+ 将您的 Zendesk 身份验证凭证存储在 AWS Secrets Manager 密钥中，如果使用 API，请记下密钥的 ARN。
**注意**  
我们建议您定期刷新或轮换您的凭证和密码。为了安全起见，请仅提供必要的访问权限级别。我们建议**不要**跨数据来源以及连接器版本 1.0 和 2.0（如果适用）重复使用凭证和密钥。

如果您没有现有的IAM角色或密钥，则可以在将 Zendesk 数据源连接到Amazon Kendra时使用控制台创建新的IAM角色和Secrets Manager密钥。如果您使用的是 API，则必须提供现有IAM角色和Secrets Manager密钥的 ARN 以及索引 ID。

## 连接说明
<a name="data-source-procedure-zendesk"></a>

要Amazon Kendra连接到您的 Zendesk 数据源，您必须提供 Zendesk 数据源的必要详细信息，Amazon Kendra以便访问您的数据。如果您尚未为 Zendesk 配置Amazon Kendra，请参阅[先决条件](#prerequisites-zendesk)。

------
#### [ Console ]

**连接到 Zen Amazon Kendra desk** 

1. 登录AWS 管理控制台并打开[Amazon Kendra控制台](https://console.aws.amazon.com/kendra/)。

1. 在左侧导航窗格中，选择**索引**，然后从索引列表中选择要使用的索引。
**注意**  
您可以选择在**索引设置**下配置或编辑您的**用户访问控制**设置。

1. 在**开始使用**页面上，选择**添加数据来源**。

1. 在**添加数据来源**页面上，选择 **Zendesk 连接器**，然后选择**添加连接器**。如果使用版本 2（如果适用），请选择带有“V2.0”标签的 **Zendesk 连接器**。

1. 在**指定数据来源详细信息**页面上，输入以下信息：

   1. 在**名称和描述**中，在**数据来源名称**中输入您的数据来源的名称。可以包含连字符，但不能包含空格。

   1. （可选）**描述**：输入数据来源的描述信息。

   1. 在**默认语言**中，选择用于筛选文档以编制索引的语言。除非另行指定，否则语言默认为英语。在文档元数据中指定的语言会覆盖所选语言。

   1. 在**标签**中，用于**添加新标签**-包括可选标签以搜索和筛选您的资源或跟踪您的AWS成本。

   1. 选择**下一步**。

1. 在**定义访问权限和安全性**页面上，请输入以下信息：

   1. **Zendesk URL** - 输入 Zendesk URL。例如 *https://\$1sub-domain\$1.zendesk.com/*。

   1. **授权** - 如果您有访问控制列表（ACL）并想将其用于访问控制，请选择是开启还是关闭文档的 ACL 信息。ACL 用于指定用户和组可以访问哪些文档。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。

   1. AWS Secrets Managers@@ **ecret** —选择现有密钥或创建新Secrets Manager密钥来存储您的 Zendesk 身份验证凭据。如果您选择创建新密钥，则会打开 AWS Secrets Manager 密钥窗口。

      1. 创建一个使用以下结构的新密钥：

         ```
         {
                  "hostUrl": "https://yoursubdomain.zendesk.com/",
                  "accessToken": "your_access_token"
         }
         ```
**注意**  
对于 Kendra 集成，机密名称应以 “AmazonKendra-Zendesk-' 开头，然后是你选择的标识符（例如 '-Zendesk-'）。AmazonKendra MyConnector

      1. 保存并添加您的密钥。

   1. **虚拟私有云（VPC）**- 您可以选择使用 VPC。如果是这样，则必须添加**子网**和 **VPC 安全组**。

   1. **身份爬网程序** – 指定是否激活 Amazon Kendra 的身份爬网程序。身份爬网程序使用文档的访问控制列表（ACL）信息，来根据用户或用户组对文档的访问权限筛选搜索结果。如果您的文档有 ACL 并选择使用您的 ACL，则也可以选择开启身份爬网程序来配置搜索结果Amazon Kendra的[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#context-filter-user-incl-datasources)。否则，如果关闭身份爬网程序，则可以公开搜索所有文档。如果您想对文档使用访问控制并且身份搜寻器已关闭，则可以使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 上传用户和群组访问信息以进行用户上下文筛选。

   1. **IAM角色**-选择现有IAM角色或创建新IAM角色来访问您的存储库凭据和索引内容。
**注意**  
IAM用于索引的角色不能用于数据源。如果您不确定是否将现有角色用于编制索引或常见问题解答，为了避免出错，请选择**创建新角色**。

   1. 选择**下一步**。

1. 在**配置同步设置**页面上，请输入以下信息：

   1. **选择内容** - 选择要从工单中爬取的内容类型，以获取帮助中心文章、社区主题等。

   1. **组织名称** - 输入 Zendesk 组织名称以筛选内容。

   1. **同步开始日期** - 输入要开始爬取内容的开始日期。

   1. **正则表达式模式** - 添加包含或排除某些文件的正则表达式模式。最多可以添加 100 个模式。

   1. **同步模式** – 选择在数据来源内容发生变化时更新索引的方式。首次与同步数据源时，Amazon Kendra默认情况下会对所有内容进行抓取和索引。如果首次同步失败，即使您没有选择“完整同步”作为同步模式，也必须执行一次完整的数据同步。
      + 完整同步：每次数据来源与索引同步时，重新为所有内容编制索引，并替换已有内容。
      + 新增、修改的同步：每次数据来源与索引同步时，仅为新增和修改的内容编制索引。Amazon Kendra 可以利用数据来源自身的内容变更跟踪机制，仅为自上次同步以来发生变化的内容编制索引。
      + 新增、已修改、已删除的同步：每次数据源与索引同步时，仅索引新内容、修改内容和已删除内容。 Amazon Kendra可以使用数据源的机制来跟踪内容更改并索引自上次同步以来更改的内容。

   1. 在**同步运行计划**的**频率**中 - 选择同步数据来源内容并更新索引的频率。

   1. 选择**下一步**。

1. 在**设置字段映射**页面上，请输入以下信息：

   1. **默认数据源字段**-从Amazon Kendra生成的默认数据源字段中选择要映射到索引的字段。

   1.  **添加字段** - 添加自定义数据来源字段以创建要映射到的索引字段名称和字段数据类型。

   1. 选择**下一步**。

1. 在**查看和创建**页面上，请检查输入的信息是否正确，然后选择**添加数据来源**。您也可以选择在此页面上编辑信息。成功添加数据来源后，您的数据来源将显示在**数据来源**页面上。

------
#### [ API ]

**连接到 Zen Amazon Kendra desk**

您必须使用 [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html) API 指定[数据来源架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html)的 JSON。您必须提供以下信息：
+ **数据来源** – 当使用 [https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html](https://docs.aws.amazon.com/kendra/latest/dg/API_TemplateConfiguration.html) JSON 架构时，将数据来源类型指定为 `ZENDESK`。当调用 [https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html](https://docs.aws.amazon.com/kendra/latest/dg/API_CreateDataSource.html) API 时，还要将数据来源指定为 `TEMPLATE`。
+ **主机 URL** - 在连接配置或存储库端点详细信息中提供您的 Zendesk 主机 URL。例如 * https://yoursubdomain.zendesk.com*。
+  **更改日志** - Amazon Kendra 是否应使用 Zendesk 数据来源的更改日志机制来判断索引中的文档是否需要更新。
**注意**  
如果您不想让 Amazon Kendra 扫描所有文档，请使用更改日志。如果您的更改日志很大，则扫描 Zendesk 数据源中的文档所花费的时间可能比处理变更日志所需的时间Amazon Kendra少。如果您是首次将 Zendesk 数据来源与索引同步，则会扫描所有文档。
+ **亚马逊秘密资源名称 (ARN)**-提供包含您的 Zendesk 账户身份验证凭证的Secrets Manager密钥的亚马逊资源名称 (ARN)。密钥必须使用具有以下键的 JSON 结构存储：

  ```
  {
      "hostUrl": "https://yoursubdomain.zendesk.com",
      "clientId": "client ID",
      "clientSecret": "Zendesk client secret",
      "userName": "Zendesk user name",
      "password": "Zendesk password"
  }
  ```
+ **IAMro** le —指定`RoleArn`何时调用`CreateDataSource`为IAM角色提供访问您的Secrets Manager密钥的权限以及调用 Zendesk 连接器 APIs 所需的公众的权限，以及。Amazon Kendra有关更多信息，请参阅 [Zendesk 数据来源的 IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds)。

您还可以添加以下可选功能：
+  **虚拟私有云（VPC）**- 指定 `VpcConfiguration`，以便调用 `CreateDataSource`。有关更多信息，请参阅 [配置 Amazon Kendra 为使用 Amazon VPC](vpc-configuration.md)。
+  **文档/内容类型** - 指定是否进行爬取：
  + Support 工单、工单评论、 and/or 工单评论附件
  + 帮助中心文章、文章附件和文章备注
  + 指南社区主题、帖子或帖子评论
+  **包含和排除筛选条件** - 指定是包含还是排除某些 Slack 内容。如果您使用机器人令牌作为 Slack 身份验证凭证的一部分，则必须将机器人令牌添加到要编制索引的频道。您无法使用机器人令牌将私信和群组消息编入索引。
**注意**  
大多数数据来源使用正则表达式模式，即称为筛选条件的包含或排除模式。如果您指定包含筛选条件，则只会为与包含筛选条件匹配的内容编制索引。不会为任何与包含筛选条件不匹配的文档编制索引。如果您指定包含和排除筛选条件，则不会为与排除筛选条件匹配的文档编制索引，即使它们与包含筛选条件相匹配。
+  **用户上下文筛选和访问控制** - 如果文档有 ACL，则 Amazon Kendra 会爬取文档的访问控制列表（ACL）。ACL 信息用于根据用户或其所在组对文档的访问权限来筛选搜索结果。有关更多信息，请参阅[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html#datasource-context-filter)。
+  **字段映射** - 选择将 Zendesk 数据来源字段映射到 Amazon Kendra 索引字段。有关更多信息，请参阅[映射数据来源字段](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html)。
**注意**  
要搜索您的文档，必须输入文档正文字段或文档正文等效字段。Amazon Kendra您必须将数据来源中的文档正文字段名映射到索引字段名称 `_document_body`。其他所有字段均为可选字段。

有关要配置的其他重要 JSON 键的列表，请参阅 [ 模板架构](https://docs.aws.amazon.com/kendra/latest/dg/ds-schemas.html#ds-schema-zendesk)。

------

## 了解详情
<a name="zendesk-learn-more"></a>

要了解有关Amazon Kendra与 Zendesk 数据源集成的更多信息，请参阅：
+ [通过Amazon Kendra智能搜索发现来自 Zendesk 的见解](https://aws.amazon.com/blogs/machine-learning/discover-insights-from-zendesk-with-amazon-kendra-intelligent-search/)

## 注意
<a name="zendesk-notes"></a>
+ 启用访问控制列表 (ACLs) 后，由于 Zendesk API 的限制，“仅同步新内容或修改内容” 选项不可用。我们建议改用 “完全同步” 或 “新建、修改或删除的内容同步” 模式，或者 ACLs 如果您需要使用此同步模式，则将其禁用。