本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # 数据迁移的源 AWS Database Migration Service (AWS DMS) 可以使用许多最流行的数据引擎作为数据复制源。数据库源可以是在 Amazon EC2 实例上运行的自管理引擎，也可以是本地数据库。或者它可以是诸如 Amazon RDS 或 Amazon S3 之类的 AWS 服务上的数据源。 有关有效来源的完整列表，请参阅 [AWS DMS的来源](CHAP_Introduction.Sources.md#CHAP_Introduction.Sources.title)。 **Topics** + [使用 Oracle 数据库作为来源 AWS DMS](CHAP_Source.Oracle.md) + [使用微软 SQL Server 数据库作为来源 AWS DMS](CHAP_Source.SQLServer.md) + [使用微软 Azure SQL 数据库作为来源 AWS DMS](CHAP_Source.AzureSQL.md) + [使用微软 Azure SQL 托管实例作为来源 AWS DMS](CHAP_Source.AzureMgd.md) + [使用适用于 PostgreSQL 灵活服务器的微软 Azure 数据库作为来源 AWS DMS](CHAP_Source.AzureDBPostgreSQL.md) + [使用适用于 MySQL 灵活服务器的微软 Azure 数据库作为来源 AWS DMS](CHAP_Source.AzureDBMySQL.md) + [使用 OCI MySQL Heatwave 作为来源 AWS DMS](CHAP_Source.heatwave.md) + [使用适用于 MySQL 的谷歌云作为来源 AWS DMS](CHAP_Source.GC.md) + [使用适用于 PostgreSQL 的谷歌云作为来源 AWS DMS](CHAP_Source.GCPostgres.md) + [使用 PostgreSQL 数据库作为源 AWS DMS](CHAP_Source.PostgreSQL.md) + [使用与 MySQL 兼容的数据库作为源 AWS DMS](CHAP_Source.MySQL.md) + [使用 SAP ASE 数据库作为来源 AWS DMS](CHAP_Source.SAP.md) + [使用 MongoDB 作为来源 AWS DMS](CHAP_Source.MongoDB.md) + [使用亚马逊 DocumentDB（兼容 MongoDB）作为来源 AWS DMS](CHAP_Source.DocumentDB.md) + [使用 Amazon S3 作为来源 AWS DMS](CHAP_Source.S3.md) + [使用适用于 Linux、Unix、Windows 的 IBM Db2 和亚马逊 RDS 数据库 (Db2 LUW) 作为来源 AWS DMS](CHAP_Source.DB2.md) + [使用 IBM Db2 作为 z/OS 数据库的来源 AWS DMS](CHAP_Source.DB2zOS.md) # 使用 Oracle 数据库作为来源 AWS DMS 您可以使用迁移一个或多个 Oracle 数据库中的数据 AWS DMS。使用 Oracle 数据库作为源，您可以将数据迁移到 AWS DMS支持的任何目标。 AWS DMS 支持以下 Oracle 数据库版本： + Oracle Enterprise Edition + Oracle Standard Edition + Oracle Express 版本 + Oracle Personal Edition 有关 AWS DMS 支持作为源的 Oracle 数据库版本的信息，请参见[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 可以使用安全套接字层 (SSL) 加密 Oracle 终端节点与您复制实例之间的连接。有关将 SSL 用于 Oracle 终端节点的更多信息，请参阅 [Oracle 终端节点的 SSL 支持](#CHAP_Security.SSL.Oracle)。 AWS DMS 支持使用 Oracle 透明数据加密 (TDE) 对源数据库中的静态数据进行加密。有关将 Oracle TDE 与 Oracle 源终端节点结合使用的更多信息，请参阅[使用 Oracle 作为数据源的支持的加密方法 AWS DMS](#CHAP_Source.Oracle.Encryption)。 AWS 支持在 Oracle 终端节点（以及所有其他端点类型）中使用 TLS 版本 1.2 及更高版本，并建议使用 TLS 版本 1.3 或更高版本。 按照以下步骤将 Oracle 数据库配置为 AWS DMS 源端点： 1. 创建具有相应权限的 Oracle 用户 AWS DMS 来访问您的 Oracle 源数据库。 1. 创建符合所选 Oracle 数据库配置的 Oracle 源端点。要创建 full-load-only任务，无需进一步配置。 1. 要创建处理变更数据捕获的任务（仅限 CDC 或满载和 CDC 任务），请选择 Oracle LogMiner 或 AWS DMS Binary Reader 来捕获数据更改。选择 LogMiner 或 Binary Reader 决定了后面的一些权限和配置选项。有关 LogMiner 和二进制阅读器的比较，请参阅以下部分。 **注意** 有关完全加载任务、仅 CDC 的任务以及完全加载和 CDC 任务的更多信息，请参阅[创建任务](CHAP_Tasks.Creating.md) 有关使用 Oracle 源数据库和的更多详细信息 AWS DMS，请参阅以下各节。 **Topics** + [在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器](#CHAP_Source.Oracle.CDC) + [配置自我管理或 AWS托管的 Oracle 源数据库的工作流 AWS DMS配置 Oracle 源数据库](#CHAP_Source.Oracle.Workflows) + [使用自行管理的 Oracle 数据库作为源 AWS DMS](#CHAP_Source.Oracle.Self-Managed) + [使用 AWS由托管的 Oracle 数据库作为源 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed) + [使用 Oracle 作为来源的限制 AWS DMS](#CHAP_Source.Oracle.Limitations) + [Oracle 终端节点的 SSL 支持](#CHAP_Security.SSL.Oracle) + [使用 Oracle 作为数据源的支持的加密方法 AWS DMS](#CHAP_Source.Oracle.Encryption) + [使用 Oracle 作为源时支持的压缩方法 AWS DMS](#CHAP_Source.Oracle.Compression) + [使用 Oracle 作为源来复制嵌套表 AWS DMS](#CHAP_Source.Oracle.NestedTables) + [使用 Oracle 作为源时在 Oracle ASM 上存储 REDO AWS DMS](#CHAP_Source.Oracle.REDOonASM) + [使用 Oracle 作为来源时的终端节点设置 AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib) + [Oracle 的源数据类型](#CHAP_Source.Oracle.DataTypes) ## 在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器 在中 AWS DMS，有两种方法可以在将 Oracle 作为源进行更改数据捕获 (CDC) 时读取重做日志：Oracle LogMiner 和 AWS DMS Binary Reader。 LogMiner 是一个 Oracle API，用于读取在线重做日志和存档的重做日志文件。Binary Reader 是一种直接读取和解析原始重做日志文件的 AWS DMS 方法。这些方法具有以下功能。 | 功能 | LogMiner | Binary Reader | | --- | --- | --- | | 易于配置 | 是 | 否 | | 降低对源系统 I/O 和 CPU 的影响 | 否 | 是 | | CDC 性能更好 | 否 | 是 | | 支持 Oracle 表集群 | 是 | 否 | | 支持所有类型的 Oracle 混合列式压缩（HCC） | 是 | 部分支持 Binary Reader 不支持在执行 CDC 的任务中使用 QUERY LOW。完全支持所有其他 HCC 类型。 | | 仅在 Oracle 12c 中支持 LOB 列 | 否（Oracle 12c LogMiner 中不提供 LOB Support。） | 是 | | 支持仅影响 LOB 列的 UPDATE 语句 | 否 | 是 | | 支持 Oracle 透明数据加密（TDE） | 部分支持 使用 Oracle 时 LogMiner， AWS DMS 不支持 Amazon RDS for Oracle 的列级别的 TDE 加密。 | 部分支持 Binary Reader 仅支持自管理 Oracle 数据库的 TDE。 | | 支持所有 Oracle 压缩方法 | 是 | 否 | | 支持 XA 事务 | 否 | 是 | | RAC | 是 由于性能原因和一些内部 DMS 限制，不建议这样做。 | 是 强烈建议 | **注意** 默认情况下， AWS DMS 使用 Oracle LogMiner 进行 (CDC)。 AWS DMS 在使用 Oracle 源数据库时支持透明数据加密 (TDE) 方法。如果您指定的 TDE 凭证不正确， AWS DMS 迁移任务不会失败，这可能会影响加密表的持续复制。有关指定 TDE 凭证的更多信息，请参阅[使用 Oracle 作为数据源的支持的加密方法 AWS DMS](#CHAP_Source.Oracle.Encryption)。 LogMiner 与一起使用的主要优点 AWS DMS 包括以下几点： + LogMiner 支持大多数 Oracle 选项，例如加密选项和压缩选项。Binary Reader 并不支持所有的 Oracle 选项，特别是压缩选项和大多数加密选项。 + LogMiner 提供了更简单的配置，尤其是与 Binary Reader 直接访问设置或使用 Oracle 自动存储管理 (ASM) 管理重做日志时。 + LogMiner 支持表群集供使用 AWS DMS。Binary Reader 没有这种支持。 使用二进制阅读器的主要优点 AWS DMS 包括以下几点： + 对于更改量大的迁移， LogMiner 可能会对托管 Oracle 源数据库的计算机产生一些影响 I/O 或 CPU 影响。Binary Reader 受到影响 I/O 或 CPU 的几率较小，因为日志是直接挖掘的，而不是进行多个数据库查询。 + 对于变更量大的迁移，与使用 Oracle LogMiner 相比，使用 Binary Reader 时 CDC 的性能通常要好得多。 + LOBs 在 Oracle 版本 12c 中，二进制阅读器支持 CDC。 LogMiner 不是。 通常，除非出现以下情况之一，否则使用 Oracle 迁移您的 Oracle 数据库： LogMiner + 需要在源 Oracle 数据库上运行多个迁移任务。 + 源 Oracle 数据库上的更改量或重做日志量很大，或者您有更改并且还在使用 Oracle ASM。 **注意** 如果您在使用 Oracle LogMiner 和 AWS DMS Binary Reader 之间切换，请务必重新启动 CDC 任务。 ### Oracle 源数据库上的 CDC 的配置 要将 Oracle 源端点连接到数据库以执行更改数据捕获（CDC）任务，您可能需要指定额外的连接属性。对于完全加载和 CDC 任务，或者仅 CDC 的任务，都可能如此。您指定的额外连接属性取决于您用来访问重做日志的方法：Oracle LogMiner 或 AWS DMS Binary Reader。 您在创建源端点时指定了额外的连接属性。如果您具有多个连接属性设置，请用分号将它们彼此分开，并且不需要额外的空格（例如，`oneSetting;thenAnother`）。 AWS DMS LogMiner 默认使用。您无需指定额外连接属性即可使用它。 要使用 Binary Reader 访问重做日志，请添加以下额外连接属性。 ``` useLogMinerReader=N;useBfile=Y; ``` 为额外连接属性使用以下格式来访问将 ASM 与 Binary Reader 一起使用的服务器。 ``` useLogMinerReader=N;useBfile=Y;asm_user=asm_username;asm_server=RAC_server_ip_address:port_number/+ASM; ``` 如下所示将源终端节点 `Password` 请求参数设置为 Oracle 用户密码和 ASM 密码，以逗号分隔。 ``` oracle_user_password,asm_user_password ``` 如果 Oracle 源使用 ASM，您可以使用 Binary Reader 中的高性能选项进行大规模事务处理。这些选项包括额外的连接属性，用于指定并行线程数 (`parallelASMReadThreads`) 和预读缓冲区数 (`readAheadBlocks`)。同时设置这些属性可以显著提高 CDC 任务的性能。以下设置为大多数 ASM 配置提供了良好的结果。 ``` useLogMinerReader=N;useBfile=Y;asm_user=asm_username;asm_server=RAC_server_ip_address:port_number/+ASM; parallelASMReadThreads=6;readAheadBlocks=150000; ``` 有关额外连接属性支持的值的更多信息，请参阅[使用 Oracle 作为来源时的终端节点设置 AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)。 此外，对使用 ASM 的 Oracle 源执行 CDC 任务的性能取决于您选择的其他设置。这些设置包括用于配置 Oracle 源的 AWS DMS 额外连接属性和 SQL 设置。有关使用 ASM 的 Oracle 源的额外连接属性的更多信息，请参阅[使用 Oracle 作为来源时的终端节点设置 AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)。 您还需要选择适当的 CDC 开始点。通常，在执行此操作时，您需要确定从哪个事务处理点捕获最早的未结事务，以便启动 CDC。否则，CDC 任务可能会错过之前的未结事务。对于 Oracle 源数据库，您可以根据 Oracle 系统更改号（SCN）选择 CDC 本机开始点，以此来确定最早的未结事务。有关更多信息，请参阅 [从 CDC 开始点开始执行复制](CHAP_Task.CDC.md#CHAP_Task.CDC.StartPoint)。 有关为使用自管理 Oracle 数据库作为源配置 CDC 的更多信息，请参阅[使用 Oracle LogMiner 访问重做日志时所需的帐户权限](#CHAP_Source.Oracle.Self-Managed.LogMinerPrivileges)、[使用 AWS DMS 二进制读取器访问重做日志时所需的帐户权限](#CHAP_Source.Oracle.Self-Managed.BinaryReaderPrivileges)和[将 Binary Reader 与 Oracle ASM 配合使用时所需的其他账户权限](#CHAP_Source.Oracle.Self-Managed.ASMBinaryPrivileges)。 有关将 CDC 配置为 AWS托管的 Oracle 数据库作为源的更多信息，请参见[将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)和。[使用 Amazon RDS Oracle 备用副本（只读副本）作为源，并使用适用于 CDC 的二进制读取器 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.StandBy) ## 配置自我管理或 AWS托管的 Oracle 源数据库的工作流 AWS DMS ## 配置 Oracle 源数据库 要配置自管理的源数据库实例，请使用以下工作流程步骤，具体取决于您执行 CDC 的方式。 | 在此工作流程步骤中 | 如果您使用执行CDC LogMiner，请执行此操作 | 如果您使用 Binary Reader 执行 CDC，请执行此操作 | | --- | --- | --- | | 授予 Oracle 账户权限。 | 请参阅 [在自行管理的 Oracle 源上需要用户帐户权限 AWS DMS](#CHAP_Source.Oracle.Self-Managed.Privileges)。 | 请参阅 [在自行管理的 Oracle 源上需要用户帐户权限 AWS DMS](#CHAP_Source.Oracle.Self-Managed.Privileges)。 | | 准备源数据库以便使用 CDC 进行复制。 | 请参阅 [使用为 CDC 准备 Oracle 自行管理的源数据库 AWS DMS](#CHAP_Source.Oracle.Self-Managed.Configuration)。 | 请参阅 [使用为 CDC 准备 Oracle 自行管理的源数据库 AWS DMS](#CHAP_Source.Oracle.Self-Managed.Configuration)。 | | 为 CDC 授予所需的其他 Oracle 用户权限。 | 请参阅 [使用 Oracle LogMiner 访问重做日志时所需的帐户权限](#CHAP_Source.Oracle.Self-Managed.LogMinerPrivileges)。 | 请参阅 [使用 AWS DMS 二进制读取器访问重做日志时所需的帐户权限](#CHAP_Source.Oracle.Self-Managed.BinaryReaderPrivileges)。 | | 对于使用 ASM 的 Oracle 实例，请为 CDC 授予访问 ASM 所需的其他用户账户权限。 | 没有其他操作。 AWS DMS 无需其他帐户权限即可支持 Oracle ASM。 | 请参阅[将 Binary Reader 与 Oracle ASM 配合使用时所需的其他账户权限](#CHAP_Source.Oracle.Self-Managed.ASMBinaryPrivileges)。 | | 如果您尚未执行此操作，请配置要使用的任务 LogMiner 或用于 CDC 的 Binary Reader。 | 请参阅 [在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器](#CHAP_Source.Oracle.CDC)。 | 请参阅 [在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器](#CHAP_Source.Oracle.CDC)。 | | 将 Oracle Standby 配置为源来执行 CDC。 | AWS DMS 不支持 Oracle 备用服务器作为源。 | 请参阅[使用自我管理的 Oracle 备用数据库作为源，并使用适用于 CDC 的二进制读取器 AWS DMS](#CHAP_Source.Oracle.Self-Managed.BinaryStandby)。 | 使用以下工作流步骤配置 AWS托管的 Oracle 源数据库实例。 | 在此工作流程步骤中 | 如果您使用执行CDC LogMiner，请执行此操作 | 如果您使用 Binary Reader 执行 CDC，请执行此操作 | | --- | --- | --- | | 授予 Oracle 账户权限。 | 有关更多信息，请参阅 [需要在 AWS托管的 Oracle 源上拥有用户帐户权限 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Privileges)。 | 有关更多信息，请参阅 [需要在 AWS托管的 Oracle 源上拥有用户帐户权限 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Privileges)。 | | 准备源数据库以便使用 CDC 进行复制。 | 有关更多信息，请参阅 [为配置由 AWS托管的 Oracle 源 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Configuration)。 | 有关更多信息，请参阅 [为配置由 AWS托管的 Oracle 源 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Configuration)。 | | 为 CDC 授予所需的其他 Oracle 用户权限。 | 不需要额外的账户权限。 | 有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。 | | 如果您尚未执行此操作，请配置要使用的任务 LogMiner 或用于 CDC 的 Binary Reader。 | 有关更多信息，请参阅 [在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器](#CHAP_Source.Oracle.CDC)。 | 有关更多信息，请参阅 [在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器](#CHAP_Source.Oracle.CDC)。 | | 将 Oracle Standby 配置为源来执行 CDC。 | AWS DMS 不支持 Oracle 备用服务器作为源。 | 有关更多信息，请参阅 [使用 Amazon RDS Oracle 备用副本（只读副本）作为源，并使用适用于 CDC 的二进制读取器 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.StandBy)。 | ## 使用自行管理的 Oracle 数据库作为源 AWS DMS *自管理数据库*是您配置和控制的数据库，它是本地数据库实例或 Amazon EC2 上的数据库。接下来，您可以了解使用自管理的 Oracle 数据库时所需的权限和配置。 AWS DMS ### 在自行管理的 Oracle 源上需要用户帐户权限 AWS DMS 要使用 Oracle 数据库作为中的源 AWS DMS，请向在 Oracle 端点连接设置中指定的 Oracle 用户授予以下权限。 **注意** 当授予权限时，请使用对象的实际名称，而不是每个对象的同义词。例如，请使用带下划线的 `V_$OBJECT`，而不是不带下划线的 `V$OBJECT`。 ``` GRANT CREATE SESSION TO dms_user; GRANT SELECT ANY TRANSACTION TO dms_user; GRANT SELECT ON V_$ARCHIVED_LOG TO dms_user; GRANT SELECT ON V_$LOG TO dms_user; GRANT SELECT ON V_$LOGFILE TO dms_user; GRANT SELECT ON V_$LOGMNR_LOGS TO dms_user; GRANT SELECT ON V_$LOGMNR_CONTENTS TO dms_user; GRANT SELECT ON V_$DATABASE TO dms_user; GRANT SELECT ON V_$THREAD TO dms_user; GRANT SELECT ON V_$PARAMETER TO dms_user; GRANT SELECT ON V_$NLS_PARAMETERS TO dms_user; GRANT SELECT ON V_$TIMEZONE_NAMES TO dms_user; GRANT SELECT ON V_$TRANSACTION TO dms_user; GRANT SELECT ON V_$CONTAINERS TO dms_user; GRANT SELECT ON ALL_INDEXES TO dms_user; GRANT SELECT ON ALL_OBJECTS TO dms_user; GRANT SELECT ON ALL_TABLES TO dms_user; GRANT SELECT ON ALL_USERS TO dms_user; GRANT SELECT ON ALL_CATALOG TO dms_user; GRANT SELECT ON ALL_CONSTRAINTS TO dms_user; GRANT SELECT ON ALL_CONS_COLUMNS TO dms_user; GRANT SELECT ON ALL_TAB_COLS TO dms_user; GRANT SELECT ON ALL_IND_COLUMNS TO dms_user; GRANT SELECT ON ALL_ENCRYPTED_COLUMNS TO dms_user; GRANT SELECT ON ALL_LOG_GROUPS TO dms_user; GRANT SELECT ON ALL_TAB_PARTITIONS TO dms_user; GRANT SELECT ON SYS.DBA_REGISTRY TO dms_user; GRANT SELECT ON SYS.OBJ$ TO dms_user; GRANT SELECT ON DBA_TABLESPACES TO dms_user; GRANT SELECT ON DBA_OBJECTS TO dms_user; -– Required if the Oracle version is earlier than 11.2.0.3. GRANT SELECT ON SYS.ENC$ TO dms_user; -– Required if transparent data encryption (TDE) is enabled. For more information on using Oracle TDE with AWS DMS, see 使用 Oracle 作为数据源的支持的加密方法 AWS DMS. GRANT SELECT ON GV_$TRANSACTION TO dms_user; -– Required if the source database is Oracle RAC in AWS DMS versions 3.4.6 and higher. GRANT SELECT ON V_$DATAGUARD_STATS TO dms_user; -- Required if the source database is Oracle Data Guard and Oracle Standby is used in the latest release of DMS version 3.4.6, version 3.4.7, and higher. GRANT SELECT ON V_$DATABASE_INCARNATION TO dms_user; ``` 当您使用特定表列表时，为每个复制表授予以下附加权限。 ``` GRANT SELECT on any-replicated-table to dms_user; ``` 授予以下额外权限，即可使用验证功能。 ``` GRANT EXECUTE ON SYS.DBMS_CRYPTO TO dms_user; ``` 如果您使用二进制读取器代替，则授予以下额外权限 LogMiner。 ``` GRANT SELECT ON SYS.DBA_DIRECTORIES TO dms_user; ``` 授予以下额外权限以公开视图。 ``` GRANT SELECT on ALL_VIEWS to dms_user; ``` 要公开视图，您还必须向源端点添加额外连接属性 `exposeViews=true`。 使用无服务器复制时，请授予以下额外权限。 ``` GRANT SELECT on dba_segments to dms_user; GRANT SELECT on v_$tablespace to dms_user; GRANT SELECT on dba_tab_subpartitions to dms_user; GRANT SELECT on dba_extents to dms_user; ``` 有关无服务器复制的更多信息，请参阅[使用无 AWS DMS 服务器](CHAP_Serverless.md)。 使用 Oracle 特定的迁移前评测时，请授予以下额外权限。 ``` GRANT SELECT on gv_$parameter to dms_user; GRANT SELECT on v_$instance to dms_user; GRANT SELECT on v_$version to dms_user; GRANT SELECT on gv_$ASM_DISKGROUP to dms_user; GRANT SELECT on gv_$database to dms_user; GRANT SELECT on dba_db_links to dms_user; GRANT SELECT on gv_$log_History to dms_user; GRANT SELECT on gv_$log to dms_user; GRANT SELECT ON DBA_TYPES TO dms_user; GRANT SELECT ON DBA_USERS to dms_user; GRANT SELECT ON DBA_DIRECTORIES to dms_user; GRANT EXECUTE ON SYS.DBMS_XMLGEN TO dms_user; ``` 有关 Oracle 特定迁移前评测的更多信息，请参阅[Oracle 评测](CHAP_Tasks.AssessmentReport.Oracle.md)。 #### 处理 Oracle Standby 未结事务的先决条件 使用 3.4.6 及更高 AWS DMS 版本时，请执行以下步骤来处理 Oracle 备用版本的未结事务。 1. 在主数据库上创建名为 `AWSDMS_DBLINK` 的数据库链接。`DMS_USER` 将使用此数据库链接连接到主数据库。请注意，此数据库链接是从备用实例执行的，用于查询主数据库上运行的未结事务。请参阅以下示例。 ``` CREATE PUBLIC DATABASE LINK AWSDMS_DBLINK CONNECT TO DMS_USER IDENTIFIED BY DMS_USER_PASSWORD USING '(DESCRIPTION= (ADDRESS=(PROTOCOL=TCP)(HOST=PRIMARY_HOST_NAME_OR_IP)(PORT=PORT)) (CONNECT_DATA=(SERVICE_NAME=SID)) )'; ``` 1. 验证是否已建立与使用 `DMS_USER` 的数据库链接的连接，如以下示例所示。 ``` select 1 from dual@AWSDMS_DBLINK ``` ### 使用为 CDC 准备 Oracle 自行管理的源数据库 AWS DMS 通过执行以下操作，准备将您的 Oracle 自管理数据库作为运行 CDC 任务的源： + [正在验证是否 AWS DMS 支持源数据库版本](#CHAP_Source.Oracle.Self-Managed.Configuration.DbVersion). + [确保已开启 ARCHIVELOG 模式](#CHAP_Source.Oracle.Self-Managed.Configuration.ArchiveLogMode). + [设置补充日志记录](#CHAP_Source.Oracle.Self-Managed.Configuration.SupplementalLogging). #### 正在验证是否 AWS DMS 支持源数据库版本 运行以下示例查询，验证 AWS DMS是否支持 Oracle 源数据库的当前版本。 ``` SELECT name, value, description FROM v$parameter WHERE name = 'compatible'; ``` 此处，`name`、`value` 和 `description` 列是数据库中某个位置的列，正根据 `name` 的值查询这些列。如果此查询运行没有错误，则 AWS DMS 支持数据库的当前版本，您可以继续迁移。如果查询引发错误，则 AWS DMS 不支持数据库的当前版本。要继续迁移，请先将 Oracle 数据库转换为支持的版本 AWS DMS。 #### 确保已开启 ARCHIVELOG 模式 您可以在两种不同的模式下运行 Oracle： `ARCHIVELOG` 模式和 `NOARCHIVELOG` 模式。要运行 CDC 任务，请在 `ARCHIVELOG` 模式下运行数据库。要知道数据库是否处于 `ARCHIVELOG` 模式，请执行以下查询。 ``` SQL> SELECT log_mode FROM v$database; ``` 如果返回到 `NOARCHIVELOG` 模式，请按照 Oracle 的指示将数据库设置为 `ARCHIVELOG`。 #### 设置补充日志记录 要捕获正在进行的更改， AWS DMS 需要在 Oracle 源数据库上启用最低限度的补充日志记录。此外，您需要对数据库中每个已复制的表启用补充日志记录。 默认情况下，在所有复制的表上 AWS DMS 添加`PRIMARY KEY`补充日志记录。 AWS DMS 要允许添加`PRIMARY KEY`补充日志记录，请为每个复制的表授予以下权限。 ``` ALTER on any-replicated-table; ``` 您可以 AWS DMS 使用 extra 连接属性`addSupplementalLogging`禁用添加的默认`PRIMARY KEY`补充日志记录。有关更多信息，请参阅 [使用 Oracle 作为来源时的终端节点设置 AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)。 如果您的复制任务使用未引用主键列的 `WHERE` 子句更新表，请务必打开补充日志记录。 **要手动设置补充日志记录** 1. 运行以下查询来验证是否为数据库启用了补充日志记录。 ``` SELECT supplemental_log_data_min FROM v$database; ``` 如果返回的结果为 `YES` 或 `IMPLICIT`，则为数据库启用了补充日志记录。 否则，请通过运行以下命令，为数据库启用补充日志记录。 ``` ALTER DATABASE ADD SUPPLEMENTAL LOG DATA; ``` 1. 确保为每个复制的表添加了所需的补充日志记录。 请考虑以下事项： + 如果向表中添加了 `ALL COLUMNS` 补充日志记录，则无需添加更多日志记录。 + 如果存在主键，请为主键添加补充日志记录。为此，您可以使用格式在主键上添加补充日志记录，也可以在数据库的主键列上添加补充日志记录。 ``` ALTER TABLE Tablename ADD SUPPLEMENTAL LOG DATA (PRIMARY KEY) COLUMNS; ALTER DATABASE ADD SUPPLEMENTAL LOG DATA (PRIMARY KEY) COLUMNS; ``` + 如果不存在主键并且表具有单个唯一索引，则将所有唯一索引的列添加到补充日志。 ``` ALTER TABLE TableName ADD SUPPLEMENTAL LOG GROUP LogGroupName (UniqueIndexColumn1[, UniqueIndexColumn2] ...) ALWAYS; ``` 使用 `SUPPLEMENTAL LOG DATA (UNIQUE INDEX) COLUMNS` 不会将唯一索引列添加到日志。 + 如果不存在主键且表有多个唯一索引，则在按字母顺序升序列表 AWS DMS 中选择第一个唯一索引。您需要像上一项那样在所选索引的列上添加补充日志记录。 使用 `SUPPLEMENTAL LOG DATA (UNIQUE INDEX) COLUMNS` 不会将唯一索引列添加到日志。 + 如果不存在主键，也没有唯一索引，则在所有列上添加补充日志记录。 ``` ALTER TABLE TableName ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS; ``` 在某些情况下，目标表主键或唯一索引不同于源表主键或唯一索引。在这些情况下，请在构成目标表主键或唯一索引的源表列上手动添加补充日志记录。 此外，如果您更改目标表主键，请在目标唯一索引的列上添加补充日志记录，而不是在原始主键或唯一索引的列上添加。 如果为表定义了筛选器或转换，则可能需要启用其他日志记录。 请考虑以下事项： + 如果向表中添加了 `ALL COLUMNS` 补充日志记录，则无需添加更多日志记录。 + 如果表具有唯一索引或主键，请在筛选器或转换中涉及的每一列上添加补充日志记录。但是，仅在这些列与主键列或唯一索引列不同时才执行此操作。 + 如果转换只包含一列，请不要将此列添加到补充日志记录组。例如，对于转换 `A+B`，请在 `A` 和 `B` 这两列上添加补充日志记录。但是，对于转换 `substring(A,10)`，请不要在列 `A` 上添加补充日志记录。 + 要在主键或唯一索引列以及经过筛选或转换的其他特定列上设置补充日志记录，可以设置 `USER_LOG_GROUP` 补充日志记录。在主键或唯一索引列和经过筛选或转换的其他特定列上添加此日志记录。 例如，要复制名为 `TEST.LOGGING` 的表，该表的主键为 `ID` 且按列 `NAME` 进行筛选，您可以运行如下命令来创建日志组补充日志记录。 ``` ALTER TABLE TEST.LOGGING ADD SUPPLEMENTAL LOG GROUP TEST_LOG_GROUP (ID, NAME) ALWAYS; ``` ### 使用 Oracle LogMiner 访问重做日志时所需的帐户权限 要使用 Oracle 访问重做日志 LogMiner，请向在 Oracle 端点连接设置中指定的 Oracle 用户授予以下权限。 ``` GRANT EXECUTE on DBMS_LOGMNR to dms_user; GRANT SELECT on V_$LOGMNR_LOGS to dms_user; GRANT SELECT on V_$LOGMNR_CONTENTS to dms_user; GRANT LOGMINING to dms_user; -– Required only if the Oracle version is 12c or higher. ``` ### 使用 AWS DMS 二进制读取器访问重做日志时所需的帐户权限 要使用 AWS DMS 二进制读取器访问重做日志，请向在 Oracle 端点连接设置中指定的 Oracle 用户授予以下权限。 ``` GRANT SELECT on v_$transportable_platform to dms_user; -– Grant this privilege if the redo logs are stored in Oracle Automatic Storage Management (ASM) and AWS DMS accesses them from ASM. GRANT CREATE ANY DIRECTORY to dms_user; -– Grant this privilege to allow AWS DMS to use Oracle BFILE read file access in certain cases. This access is required when the replication instance does not have file-level access to the redo logs and the redo logs are on non-ASM storage. GRANT EXECUTE on DBMS_FILE_TRANSFER to dms_user; -– Grant this privilege to copy the redo log files to a temporary folder using the CopyToTempFolder method. GRANT EXECUTE on DBMS_FILE_GROUP to dms_user; ``` Binary Reader 与 Oracle 文件功能（包括 Oracle 目录）配合使用。每个 Oracle 目录对象都包含要处理的重做日志文件所在文件夹的名称。这些 Oracle 目录不在文件系统级别表示。相反，它们是在 Oracle 数据库级别创建的逻辑目录。您可以在 Oracle `ALL_DIRECTORIES` 视图中查看它们。 如果 AWS DMS 要创建这些 Oracle 目录，请授予前面指定的`CREATE ANY DIRECTORY`权限。 AWS DMS 创建带有`DMS_`前缀的目录名称。如果您不授予 `CREATE ANY DIRECTORY` 权限，请手动创建相应的目录。在某些情况下，当您手动创建 Oracle 目录时，Oracle 源终端节点中指定的 Oracle 用户不是创建这些目录的用户。在这些情况下，还要授予 `READ on DIRECTORY` 特权。 **注意** AWS DMS CDC 不支持未配置为使用自动重做传输服务的 Active Dataguard 待机。 在某些情况下，您可能会使用 Oracle 管理的文件 (OMF) 来存储日志。或者，您的源端点位于 ADG 中，并且无法授予 CREATE ANY DIRECTORY 权限。在这些情况下，请在开始 AWS DMS 复制任务之前手动创建包含所有可能日志位置的目录。如果找 AWS DMS 不到预期的预先创建的目录，则任务将停止。此外， AWS DMS 不会删除它在`ALL_DIRECTORIES`视图中创建的条目，因此请手动将其删除。 ### 将 Binary Reader 与 Oracle ASM 配合使用时所需的其他账户权限 要使用 Binary Reader 访问 Automatic Storage Management（ASM）中的重做日志，请向 Oracle 端点连接设置中指定的 Oracle 用户授予以下权限。 ``` SELECT ON v_$transportable_platform SYSASM -– To access the ASM account with Oracle 11g Release 2 (version 11.2.0.2) and higher, grant the Oracle endpoint user the SYSASM privilege. For older supported Oracle versions, it's typically sufficient to grant the Oracle endpoint user the SYSDBA privilege. ``` 您可以通过打开命令提示符并调用以下语句之一来验证 ASM 账户访问权限，具体取决于前面指定的 Oracle 版本。 如果您需要 `SYSDBA` 权限，请使用以下语句。 ``` sqlplus asmuser/asmpassword@+asmserver as sysdba ``` 如果您需要 `SYSASM` 权限，请使用以下语句。 ``` sqlplus asmuser/asmpassword@+asmserver as sysasm ``` ### 使用自我管理的 Oracle 备用数据库作为源，并使用适用于 CDC 的二进制读取器 AWS DMS 要在使用 Binary Reader 执行 CDC 时将 Oracle Standby 实例配置为源，请先满足以下先决条件： + AWS DMS 目前仅支持 Oracle 主动数据防护待机。 + 确保 Oracle Data Guard 配置使用： + 重做传输服务以自动传输重做数据。 + 应用服务以自动对备用数据库应用重做。 要确认是否满足这些要求，请执行以下查询。 ``` SQL> select open_mode, database_role from v$database; ``` 从该查询的输出中，确认备用数据库是否以只读模式打开，并且正在自动应用重做。例如： ``` OPEN_MODE DATABASE_ROLE -------------------- ---------------- READ ONLY WITH APPLY PHYSICAL STANDBY ``` **要在使用 Binary Reader 执行 CDC 时将 Oracle Standby 实例配置为源** 1. 授予访问待机日志文件所需的其他权限。 ``` GRANT SELECT ON v_$standby_log TO dms_user; ``` 1. 使用 AWS 管理控制台 或 AWS CLI为 Oracle Standby 创建源端点。创建端点时，请指定以下额外的连接属性。 ``` useLogminerReader=N;useBfile=Y; ``` **注意** 在中 AWS DMS，您可以使用额外的连接属性来指定是否要从存档日志而不是重做日志中迁移。有关更多信息，请参阅 [使用 Oracle 作为来源时的终端节点设置 AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)。 1. 配置存档日志目标。 未配置 ASM 的 Oracle 源的 DMS Binary Reader 使用 Oracle 目录来访问存档的重做日志。如果您的数据库配置为使用闪回恢复区（FRA）作为存档日志目标，则存档重做文件的位置不固定。每天生成存档的重做日志会导致在 FRA 中创建一个目录名称格式为 YYYY\$1MM\$1DD 的新目录。例如： ``` DB_RECOVERY_FILE_DEST/SID/archivelog/YYYY_MM_DD ``` 当 DMS 需要访问在新创建的 FRA 目录中存档的重做文件，并且使用主读写数据库作为源时，DMS 会创建一个新的 Oracle 目录或替换现有的 Oracle 目录，如下所示。 ``` CREATE OR REPLACE DIRECTORY dmsrep_taskid AS ‘DB_RECOVERY_FILE_DEST/SID/archivelog/YYYY_MM_DD’; ``` 如果使用备用数据库作为源，DMS 无法创建或替换 Oracle 目录，因为该数据库处于只读模式。但是，您可以选择执行以下附加步骤之一： 1. 将 `log_archive_dest_id_1` 改为使用实际路径，而不使用 Oracle 不会创建每日子目录的配置中的 FRA： ``` ALTER SYSTEM SET log_archive_dest_1=’LOCATION=full directory path’ ``` 然后，创建一个供 DMS 使用的 Oracle 目录对象： ``` CREATE OR REPLACE DIRECTORY dms_archived_logs AS ‘full directory path’; ``` 1. 创建一个额外的存档日志目标和一个指向该目标的 Oracle 目录对象。例如： ``` ALTER SYSTEM SET log_archive_dest_3=’LOCATION=full directory path’; CREATE DIRECTORY dms_archived_log AS ‘full directory path’; ``` 然后向任务源端点添加一个额外的连接属性： ``` archivedLogDestId=3 ``` 1. 手动预创建一个供 DMS 使用的 Oracle 目录对象。 ``` CREATE DIRECTORY dms_archived_log_20210301 AS ‘DB_RECOVERY_FILE_DEST/SID/archivelog/2021_03_01’; CREATE DIRECTORY dms_archived_log_20210302 AS ‘DB_RECOVERY_FILE_DEST>/SID>/archivelog/2021_03_02’; ... ``` 1. 创建每天运行的 Oracle 调度程序任务，并创建所需的目录。 1. 配置在线日志目标。 创建指向带有备用重做日志的操作系统目录的 Oracle 目录： ``` CREATE OR REPLACE DIRECTORY STANDBY_REDO_DIR AS ''; GRANT READ ON DIRECTORY STANDBY_REDO_DIR TO ; ``` ### 在 Oracle 云基础设施 (OCI) 上使用用户管理的数据库作为 CDC 的来源 AWS DMS 用户管理的数据库是您配置和控制的数据库，例如在虚拟机（VM）、裸机或 Exadata 服务器上创建的 Oracle 数据库。或是您配置和控制的在专用基础架构上运行的数据库，例如 Oracle Cloud Infrastructure（OCI）。以下信息描述了在 OCI 上使用 Oracle 用户管理的数据库作为在 AWS DMS中执行更改数据捕获（CDC）源时所需的权限和配置。 **要将由 OCI 托管的用户管理的 Oracle 数据库配置为更改数据捕获源** 1. 为 OCI 上用户管理的 Oracle 源数据库授予所需的用户账户权限。有关更多信息，请参阅[自管理 Oracle 源端点的账户权限](#CHAP_Source.Oracle.Self-Managed.Privileges)。 1. 授予使用 Binary Reader 访问重做日志时所需的账户权限。有关更多信息，请参阅[使用 Binary Reader 时所需的账户权限](#CHAP_Source.Oracle.Self-Managed.BinaryReaderPrivileges)。 1. 添加将 Binary Reader 与 Oracle Automatic Storage Management（ASM）结合使用时所需的账户权限。有关更多信息，请参阅[将 Binary Reader 与 Oracle ASM 结合使用时所需的其他账户权限](#CHAP_Source.Oracle.Self-Managed.ASMBinaryPrivileges)。 1. 设置补充日志记录。有关更多信息，请参阅[设置补充日志记录](#CHAP_Source.Oracle.Self-Managed.Configuration.SupplementalLogging)。 1. 设置 TDE 加密。有关更多信息，请参阅[将 Oracle 数据库用作源端点时使用的加密方法](#CHAP_Source.Oracle.Encryption)。 在 Oracle Cloud Infrastructure（OCI）上从 Oracle 源数据库复制数据时，存在以下限制。 **限制** + DMS 不支持使用 Oracle LogMiner 访问重做日志。 + DMS 不支持自治数据库。 ## 使用 AWS由托管的 Oracle 数据库作为源 AWS DMS AWS托管数据库是位于亚马逊服务（例如 Amazon RDS、Amazon Aurora 或 Amazon S3）上的数据库。接下来，您可以找到使用 AWS托管的 Oracle 数据库时需要设置的权限和配置。 AWS DMS ### 需要在 AWS托管的 Oracle 源上拥有用户帐户权限 AWS DMS 向 Oracle 源端点定义中指定的 Oracle 用户账户授予以下权限。 **重要** 对于所有参数值（例如 `dms_user` 和 `any-replicated-table`），除非您使用区分大小写的标识符指定值，否则 Oracle 会假定值全部大写。例如，假设您在创建 `dms_user` 值时未使用引号，例如 `CREATE USER myuser` 或 `CREATE USER MYUSER`。在这种情况下，Oracle 会识别此值并以全部大写的形式存储（`MYUSER`）。如果使用引号（例如 `CREATE USER "MyUser"` 或 `CREATE USER 'MyUser'`），Oracle 会识别并存储您指定的区分大小写的值（`MyUser`）。 ``` GRANT CREATE SESSION to dms_user; GRANT SELECT ANY TRANSACTION to dms_user; GRANT SELECT on DBA_TABLESPACES to dms_user; GRANT SELECT ON any-replicated-table to dms_user; GRANT EXECUTE on rdsadmin.rdsadmin_util to dms_user; -- For Oracle 12c or higher: GRANT LOGMINING to dms_user; – Required only if the Oracle version is 12c or higher. ``` 此外，还要使用如下所示的 Amazon RDS 过程 `rdsadmin.rdsadmin_util.grant_sys_object` 为 `SYS` 对象授予 `SELECT` 和 `EXECUTE` 权限。有关更多信息，请参阅[向 SYS 对象授予 SELECT 或 EXECUTE 权限](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html#Appendix.Oracle.CommonDBATasks.TransferPrivileges)。 ``` exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_VIEWS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_TAB_PARTITIONS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_INDEXES', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_OBJECTS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_TABLES', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_USERS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_CATALOG', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_CONSTRAINTS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_CONS_COLUMNS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_TAB_COLS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_IND_COLUMNS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_LOG_GROUPS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$ARCHIVED_LOG', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOG', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOGFILE', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$DATABASE', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$THREAD', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$PARAMETER', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$NLS_PARAMETERS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$TIMEZONE_NAMES', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$TRANSACTION', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$CONTAINERS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_REGISTRY', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('OBJ$', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_ENCRYPTED_COLUMNS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOGMNR_LOGS', 'dms_user', 'SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOGMNR_CONTENTS','dms_user','SELECT'); exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_LOGMNR', 'dms_user', 'EXECUTE'); -- (as of Oracle versions 12.1 and higher) exec rdsadmin.rdsadmin_util.grant_sys_object('REGISTRY$SQLPATCH', 'dms_user', 'SELECT'); -- (for Amazon RDS Active Dataguard Standby (ADG)) exec rdsadmin.rdsadmin_util.grant_sys_object('V_$STANDBY_LOG', 'dms_user', 'SELECT'); -- (for transparent data encryption (TDE)) exec rdsadmin.rdsadmin_util.grant_sys_object('ENC$', 'dms_user', 'SELECT'); -- (for validation with LOB columns) exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_CRYPTO', 'dms_user', 'EXECUTE'); -- (for binary reader) exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_DIRECTORIES','dms_user','SELECT'); -- Required when the source database is Oracle Data guard, and Oracle Standby is used in the latest release of DMS version 3.4.6, version 3.4.7, and higher. exec rdsadmin.rdsadmin_util.grant_sys_object('V_$DATAGUARD_STATS', 'dms_user', 'SELECT'); ``` 有关将 Amazon RDS Active Dataguard Standby（ADG）与 AWS DMS 配合使用的更多信息，请参阅[使用 Amazon RDS Oracle 备用副本（只读副本）作为源，并使用适用于 CDC 的二进制读取器 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.StandBy)。 有关将 Oracle TDE 与配合使用的更多信息 AWS DMS，请参阅[使用 Oracle 作为数据源的支持的加密方法 AWS DMS](#CHAP_Source.Oracle.Encryption)。 #### 处理 Oracle Standby 未结事务的先决条件 使用 3.4.6 及更高 AWS DMS 版本时，请执行以下步骤来处理 Oracle 备用版本的未结事务。 1. 在主数据库上创建名为 `AWSDMS_DBLINK` 的数据库链接。`DMS_USER` 将使用此数据库链接连接到主数据库。请注意，此数据库链接是从备用实例执行的，用于查询主数据库上运行的未结事务。请参阅以下示例。 ``` CREATE PUBLIC DATABASE LINK AWSDMS_DBLINK CONNECT TO DMS_USER IDENTIFIED BY DMS_USER_PASSWORD USING '(DESCRIPTION= (ADDRESS=(PROTOCOL=TCP)(HOST=PRIMARY_HOST_NAME_OR_IP)(PORT=PORT)) (CONNECT_DATA=(SERVICE_NAME=SID)) )'; ``` 1. 验证是否已建立与使用 `DMS_USER` 的数据库链接的连接，如以下示例所示。 ``` select 1 from dual@AWSDMS_DBLINK ``` ### 为配置由 AWS托管的 Oracle 源 AWS DMS 在使用 AWS托管的 Oracle 数据库作为源之前 AWS DMS，请对 Oracle 数据库执行以下任务： + 启用自动备份。有关启用自动备份的更多信息，请参阅《Amazon RDS 用户指南》**中的[启用自动备份](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html#USER_WorkingWithAutomatedBackups.Enabling)。 + 设置补充日志记录。 + 设置存档。存档适用于 Oracle 的 Amazon RDS 数据库实例的重做日志 AWS DMS 允许使用 Oracle LogMiner 或 Binary Reader 检索日志信息。 **设置存档** 1. 运行 `rdsadmin.rdsadmin_util.set_configuration` 命令以设置存档。 例如，要将已存档的重做日志保留 24 小时，请运行以下命令。 ``` exec rdsadmin.rdsadmin_util.set_configuration('archivelog retention hours',24); commit; ``` **注意** 要使更改生效，必须执行提交操作。 1. 确保您的存储具有足够的空间，可以满足指定保留期内的存档重做日志需求。例如，如果您的保留期为 24 小时，请计算在典型的事务处理小时内累积的存档重做日志的总大小，然后将该总大小乘以 24。将计算得出的 24 小时总存储空间与您的可用存储空间进行比较，确定是否有足够的存储空间来处理整整 24 小时的事务。 **设置补充日志记录** 1. 运行以下命令在数据库级别启用补充日志记录。 ``` exec rdsadmin.rdsadmin_util.alter_supplemental_logging('ADD'); ``` 1. 运行以下命令为主键列启用补充日志记录。 ``` exec rdsadmin.rdsadmin_util.alter_supplemental_logging('ADD','PRIMARY KEY'); ``` 1. （可选）在表级别启用键级别补充日志记录。 启用键级别补充日志记录时，您的源数据库会产生少量开销。因此，如果您仅迁移一部分表，可能需要在表级别启用键级别补充日志记录。要在表级别启用键级别补充日志记录，请运行以下命令。 ``` alter table table_name add supplemental log data (PRIMARY KEY) columns; ``` ### 将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS 您可以配置 AWS DMS 为使用适用于 CDC 的二进制读取器访问源 Amazon RDS for Oracle 实例重做日志。 **注意** 要使用 Oracle LogMiner，所需的最低用户帐户权限就足够了。有关更多信息，请参阅 [需要在 AWS托管的 Oracle 源上拥有用户帐户权限 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Privileges)。 要使用 AWS DMS Binary Reader，请根据您的 AWS DMS 版本为 Oracle 源端点指定其他设置和额外连接属性。 以下版本的 Amazon RDS for Oracle 支持 Binary Reader： + Oracle 11.2 – 版本 11.2.0.4V11 及更高版本 + Oracle 12.1 – 版本 12.1.0.2.V7 及更高版本 + Oracle 12.2 – 所有版本 + Oracle 18.0 – 所有版本 + Oracle 19.0 – 所有版本 **使用 Binary Reader 配置 CDC** 1. 以主用户身份登录您的 Amazon RDS for Oracle 源数据库，然后运行以下存储过程来创建服务器级目录。 ``` exec rdsadmin.rdsadmin_master_util.create_archivelog_dir; exec rdsadmin.rdsadmin_master_util.create_onlinelog_dir; ``` 1. 向用于访问 Oracle 源端点的 Oracle 用户账户授予以下权限。 ``` GRANT READ ON DIRECTORY ONLINELOG_DIR TO dms_user; GRANT READ ON DIRECTORY ARCHIVELOG_DIR TO dms_user; ``` 1. 在 Amazon RDS Oracle 源端点上设置以下额外连接属性： + 对于 RDS Oracle 版本 11.2 和 12.1，请设置以下内容。 ``` useLogminerReader=N;useBfile=Y;accessAlternateDirectly=false;useAlternateFolderForOnline=true; oraclePathPrefix=/rdsdbdata/db/{$DATABASE_NAME}_A/;usePathPrefix=/rdsdbdata/log/;replacePathPrefix=true; ``` + 对于 RDS Oracle 版本 12.2、18.0 和 19.0，请设置以下内容。 ``` useLogminerReader=N;useBfile=Y; ``` **注意** 对于多个属性设置，请确保分号分隔符（;）后面没有空格（例如，`oneSetting;thenAnother`）。 有关配置 CDC 任务的更多信息，请参阅[Oracle 源数据库上的 CDC 的配置](#CHAP_Source.Oracle.CDC.Configuration)。 ### 使用 Amazon RDS Oracle 备用副本（只读副本）作为源，并使用适用于 CDC 的二进制读取器 AWS DMS 要将 Amazon RDS for Oracle Standby 作为在 AWS DMS中使用 Binary Reader 执行 CDC 的源，请验证以下先决条件： + 使用 Oracle 主用户设置 Binary Reader。 + 确保 AWS DMS 当前仅支持使用 Oracle 主动数据防护待机。 完成此操作后，请按照以下步骤将 RDS for Oracle Standby 作为使用 Binary Reader 执行 CDC 的源。 **要在使用 Binary Reader 执行 CDC 时将 RDS for Oracle Standby 配置为源** 1. 以主用户身份登录 RDS for Oracle 主实例。 1. 运行《Amazon RDS 用户指南》中记录的以下存储过程来创建服务器级目录。 ``` exec rdsadmin.rdsadmin_master_util.create_archivelog_dir; exec rdsadmin.rdsadmin_master_util.create_onlinelog_dir; ``` 1. 确定在步骤 2 中创建的目录。 ``` SELECT directory_name, directory_path FROM all_directories WHERE directory_name LIKE ( 'ARCHIVELOG_DIR_%' ) OR directory_name LIKE ( 'ONLINELOG_DIR_%' ) ``` 例如，前面的代码显示了如下所示的目录列表。 ![\[Table showing directory names and their corresponding paths for archive and online logs.\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-rds-server-level-directories.png) 1. 向用于访问 Oracle Standby 的 Oracle 用户账户授予上述目录的 `Read` 权限。 ``` GRANT READ ON DIRECTORY ARCHIVELOG_DIR_A TO dms_user; GRANT READ ON DIRECTORY ARCHIVELOG_DIR_B TO dms_user; GRANT READ ON DIRECTORY ONLINELOG_DIR_A TO dms_user; GRANT READ ON DIRECTORY ONLINELOG_DIR_B TO dms_user; ``` 1. 在主实例上执行存档日志切换。这样做可以确保将对 `ALL_DIRECTORIES` 的更改也移植到 Oracle Standby。 1. 在 Oracle Standby 上运行 `ALL_DIRECTORIES` 查询来确认已应用更改。 1. 使用 AWS DMS 管理控制台或 AWS Command Line Interface (AWS CLI) 为 Oracle 备用服务器创建源端点。创建端点时，请指定以下额外的连接属性。 ``` useLogminerReader=N;useBfile=Y;archivedLogDestId=1;additionalArchivedLogDestId=2 ``` 1. 创建终端节点后，使用控制台的 “**创建端点**” 页面上的**测试端点连接**或 AWS CLI `test-connection`命令来验证连接是否已建立。 ## 使用 Oracle 作为来源的限制 AWS DMS 将 Oracle 数据库作为 AWS DMS源时，存在以下限制： + AWS DMS 支持 3.5.0 及更高 AWS DMS 版本中的 Oracle 扩展数据类型。 + AWS DMS 不支持长对象名（超过 30 字节）。 + AWS DMS 不支持基于函数的索引。 + 如果您管理补充日志记录并对任何列执行转换，请确保为所有字段和列激活补充日志记录。有关设置补充日志记录的信息，请参阅以下主题： + 对于自管理 Oracle 源数据库，请参阅[设置补充日志记录](#CHAP_Source.Oracle.Self-Managed.Configuration.SupplementalLogging)。 + 有关 AWS托管的 Oracle 源数据库，请参见[为配置由 AWS托管的 Oracle 源 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Configuration)。 + AWS DMS 不支持多租户容器根数据库 (CDB\$1ROOT)。但它支持使用 Binary Reader 的 PDB。 + AWS DMS 不支持延迟约束。 + AWS DMS 3.5.3 及以上版本完全支持安全 LOBs。 + AWS DMS 支持所有支持的 Oracle 版本 11 及更高版本的`rename table table-name to new-table-name`语法。但不支持任何 Oracle 版本 10 的源数据库中的此语法。 + AWS DMS 不会复制 DDL 语句`ALTER TABLE ADD column data_type DEFAULT default_value`的结果。它将新列设置为 `NULL`，而不是将 `default_value` 复制到目标。 + 使用 3.4.7 或更高 AWS DMS 版本时，要复制因分区或子分区操作而产生的更改，请在启动 DMS 任务之前执行以下操作。 + 手动创建分区表结构（DDL）； + 确保 Oracle 源和 Oracle 目标上的 DDL 相同； + 设置额外的连接属性 `enableHomogenousPartitionOps=true`。 有关 `enableHomogenousPartitionOps`的更多信息，请参阅[使用 Oracle 作为来源时的终端节点设置 AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)。另请注意，在 FULL\$1CDC 任务中，DMS 不会复制作为缓存更改的一部分捕获的数据更改。在该使用案例中，将在 Oracle 目标上重新创建表结构并重新加载有问题的表。 3.4.7 之前的 AWS DMS 版本： DMS 不复制由于分区或子分区操作（`ADD`、`DROP`、`EXCHANGE` 和 `TRUNCATE`）而导致的数据更改。此类更新可能会导致复制过程中出现以下错误： + 对于 `ADD` 操作，对添加的数据进行更新和删除可能会引发 “0 rows affected (0 行受到影响)” 警告。 + 对于 `DROP` 和 `TRUNCATE` 操作，新插入可能会引发“duplicates (重复项)” 错误。 + `EXCHANGE` 操作可能会引发 “0 rows affected (0 行受到影响)” 警告和“duplicates (重复项)” 错误。 要复制由于分区或子分区操作而导致的更改，请重新加载有问题的表。添加新的空分区之后，对新添加的表执行的操作将正常复制到目标。 + AWS DMS 3.4 之前的版本不支持在源代码上运行`CREATE TABLE AS`语句所导致的目标数据更改。但是，在目标上会创建新表。 + AWS DMS 不捕获 Oracle `DBMS_REDEFINITION` 包所做的更改，例如表元数据和`OBJECT_ID`字段。 + 启用有限大小 LOB 模式后，Oracle 源上的空 BLOB/CLOB 列将复制为 NULL 值。启用完整 LOB 模式后，它们会被复制为空字符串（' '）。 + 使用 Oracle 11 捕获更改时 LogMiner，字符串长度大于 1982 的 CLOB 列的更新会丢失，目标也不会更新。 + 在更改数据捕获 (CDC) 期间， AWS DMS 不支持对定义为主键的数字列进行批量更新。 + AWS DMS 不支持某些`UPDATE`命令。以下示例是一个不支持的 `UPDATE` 命令。 ``` UPDATE TEST_TABLE SET KEY=KEY+1; ``` 此处，`TEST_TABLE` 是表名称，`KEY` 是定义为主键的数值列。 + AWS DMS 不支持使用完整 LOB 模式加载长整列和长 RAW 列。但您可以使用受限的 LOB 模式将这些数据类型迁移到 Oracle 目标。在受限 LOB 模式下，将所有设置为长度超过 64 KB 的 LONG 或 LONG RAW 列的数据 AWS DMS 截断为 64 KB。 + AWS DMS 不支持用于加载 XMLTYPE 列的完整 LOB 模式。但您可以使用受限的 LOB 模式将 XMLTYPE 列迁移到 Oracle 目标。在受限 LOB 模式下，DMS 会截断大于用户定义的“最大 LOB 大小”变量的任何数据。“最大 LOB 大小”的最大建议值为 100MB。 + AWS DMS 不会复制名称中包含撇号的表。 + AWS DMS 从物化视图中支持 CDC。但是，DMS 不支持从其他任何视图执行 CDC。 + AWS DMS 不支持 CDC 用于按索引组织的带有溢出段的表。 + AWS DMS 不支持对按引用分区且`enableHomogenousPartitionOps`设置为`true`的表`Drop Partition`执行操作。 + 使用 Oracle LogMiner 访问重做日志时， AWS DMS 有以下限制： + 仅适用于 Oracle 12， AWS DMS 不会复制对 LOB 列的任何更改。 + AWS DMS 使用 Oracle 时不支持复制中的 XA 事务 LogMiner。 + Oracle LogMiner 不支持与可插拔数据库 (PDB) 的连接。要连接到 PDB，请使用 Binary Reader 访问重做日志。 + 不支持缩小空间操作。 + 当你使用二进制阅读器时， AWS DMS 有以下限制： + 它不支持表集群。 + 它仅支持表级别的 `SHRINK SPACE` 操作。此级别包括完整的表、分区和子分区。 + 它不支持使用键压缩对索引组织的表进行更改。 + 它不支持在原始设备上实现在线重做日志。 + Binary Reader 仅支持自管理 Oracle 数据库的 TDE，因为 RDS for Oracle 不支持为 TDE 加密密钥检索 Wallet 密码。 + AWS DMS 不支持使用 Oracle 自动存储管理 (ASM) 代理连接到 Amazon RDS Oracle 源。 + AWS DMS 不支持虚拟列。 + AWS DMS 不支持`ROWID`数据类型或基于 ROWID 列的实例化视图。 AWS DMS 部分支持 Oracle 实体化视图。对于完全加载，DMS 可以执行 Oracle 实体化视图的完全加载副本。DMS 将实体化视图作为基表复制到目标系统，并忽略实体化视图中的所有 ROWID 列。对于持续复制（CDC），DMS 会尝试复制对实体化视图数据的更改，但结果可能并不理想。具体而言，如果实体化视图已完全刷新，DMS 会复制所有行的单个删除操作，然后复制所有行的单个插入操作。这是一种资源密集型操作，对于具有大量行的实体化视图，可能表现不佳。对于实例化视图快速刷新的持续复制，DMS 会尝试处理并复制快速刷新数据更改。无论哪种情况，DMS 都会跳过实体化视图中的所有 ROWID 列。 + AWS DMS 不会加载或捕获全局临时表。 + 对于使用复制的 S3 目标，请在每列上启用补充日志记录，以便源行更新可以捕获每列的值。下面是示例：`alter table yourtablename add supplemental log data (all) columns;`。 + 无法在目标上复制使用包含 `null` 的复合唯一键的行的更新。 + AWS DMS 不支持在同一个源端点上使用多个 Oracle TDE 加密密钥。每个端点只能有一个用于 TDE 加密密钥名称“`securityDbEncryptionName`”的属性，以及该密钥的一个 TDE 密码。 + 从 Amazon RDS for Oracle 进行复制时，只有加密的表空间和使用 Oracle 才支持 TDE。 LogMiner + AWS DMS 不支持快速连续执行多个表重命名操作。 + 使用 Oracle 19.0 作为源代码时， AWS DMS 不支持以下功能： + 数据保护 DML 重定向 + 混合分区表 + 仅架构的 Oracle 账户 + AWS DMS 不支持迁移类型为或的表`BIN$`或视图`DR$`。 + 从 Oracle 18.x 开始， AWS DMS 不支持 Oracle Express 版（Oracle Database XE）中的变更数据捕获 (CDC)。 + 从 CHAR 列迁移数据时，DMS 会截断所有尾随空格。 + AWS DMS 不支持从应用程序容器复制。 + AWS DMS 不支持执行 Oracle 闪回数据库和还原点，因为这些操作会影响 Oracle 重做日志文件的一致性。 + 在 3.5.3 AWS DMS 版之前，在以下情况下不支持带有 parallel 执行选项的 Direct-Load `INSERT` 过程： + 超过 255 列的未压缩表 + 行大小超过 8K + Exadata HCC 表 + 在 Big Endian 平台上运行的数据库 + 既没有主键也没有唯一键的源表需要启用 ALL COLUMN 补充日志记录。它会创建更多的重做日志活动，并可能增加 DMS CDC 延迟。 + AWS DMS 不会迁移源数据库中不可见列的数据。要将这些列纳入迁移范围内，请使用 `ALTER TABLE` 语句使这些列可见。 + 对于所有 Oracle 版本， AWS DMS 不会复制对 LOB 列`XMLTYPE`和 LOB 列进行`UPDATE`操作的结果。 + AWS DMS 不支持从具有时间有效性限制的表中进行复制。 + 如果 Oracle 源在满载任务期间不可用，则即使数据迁移仍未完成，也 AWS DMS 可能会在多次尝试重新连接后将任务标记为已完成。在这种情况下，目标表仅包含连接中断之前迁移的记录，这可能会在源系统和目标系统之间造成数据不一致。为确保数据的完整性，您必须完全重新启动满载任务，或者重新加载受连接中断影响的特定表。 ## Oracle 终端节点的 SSL 支持 AWS DMS Oracle 终端节点支持适用于`none`和 SS `verify-ca` L 模式的 SSL V3。要将 SSL 用于 Oracle 终端节点，请上传终端节点的 Oracle wallet 而不是 .pem 证书文件。 **Topics** + [为 Oracle SSL 使用现有证书](#CHAP_Security.SSL.Oracle.Existing) + [使用适用于 Oracle SSL 的自签名证书](#CHAP_Security.SSL.Oracle.SelfSigned) ### 为 Oracle SSL 使用现有证书 要使用现有的 Oracle 客户端安装，从 CA 证书文件创建 Oracle wallet 文件，请执行以下步骤。 **要使用现有的 Oracle 客户机安装的 Oracle SSL AWS DMS** 1. 通过运行以下命令将 `ORACLE_HOME` 系统变量设置为 `dbhome_1` 目录的位置。 ``` prompt>export ORACLE_HOME=/home/user/app/user/product/12.1.0/dbhome_1 ``` 1. 将 `$ORACLE_HOME/lib` 附加到 `LD_LIBRARY_PATH` 系统变量。 ``` prompt>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib ``` 1. 为 `$ORACLE_HOME/ssl_wallet` 处的 Oracle wallet 创建一个目录。 ``` prompt>mkdir $ORACLE_HOME/ssl_wallet ``` 1. 将 CA 证书 `.pem` 文件放入 `ssl_wallet` 目录中。如果使用 Amazon RDS，则可下载由 Amazon RDS 托管的 `rds-ca-2015-root.pem` 根 CA 证书文件。有关下载此文件的更多信息，请参阅 *Amazon RDS 用户指南*中的[使用 SSL/TLS 加密与数据库实例的连接](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html)。 1. 如果您的 CA 证书包含多个 PEM 文件（例如 Amazon RDS 全球或区域捆绑包），则必须将其拆分为单独的文件，然后使用以下 bash 脚本将其添加到 Oracle Wallet 中。此脚本需要输入两个参数：CA 证书的路径和先前创建的 Oracle Wallet 的文件夹路径。 ``` #!/usr/bin/env bash certnum=$(grep -c BEGIN <(cat $1)) cnt=0 temp_cert="" while read line do if [ -n "$temp_cert" -a "$line" == "-----BEGIN CERTIFICATE-----" ] then cnt=$(expr $cnt + 1) printf "\rImporting certificate # $cnt of $certnum" orapki wallet add -wallet "$2" -trusted_cert -cert <(echo -n "${temp_cert}") -auto_login_only 1>/dev/null 2>/dev/null temp_cert="" fi temp_cert+="$line"$'\n' done < <(cat $1) cnt=$(expr $cnt + 1) printf "\rImporting certificate # $cnt of $certnum" orapki wallet add -wallet "$2" -trusted_cert -cert <(echo -n "${temp_cert}") -auto_login_only 1>/dev/null 2>/dev/null echo "" ``` 完成前面的步骤之后，您可以通过指定 certificate-wallet 参数，使用 `ImportCertificate` API 调用来导入 wallet 文件。然后，在创建或修改 Oracle 终端节点时，如果选择 `verify-ca` 作为 SSL 模式，您可以使用导入的 wallet 证书。 **注意** 甲骨文钱包是二进制文件。 AWS DMS 按原样接受这些文件。 ### 使用适用于 Oracle SSL 的自签名证书 要将自签名证书用于 Oracle SSL，请假设 Oracle 钱包密码为 `oracle123`，执行以下步骤。 **要使用适用于 Oracle SSL 的自签名证书 AWS DMS** 1. 创建一个您将用于处理自签名证书的目录。 ``` mkdir -p /u01/app/oracle/self_signed_cert ``` 1. 转到您在上一步创建的目录中。 ``` cd /u01/app/oracle/self_signed_cert ``` 1. 创建根密钥。 ``` openssl genrsa -out self-rootCA.key 2048 ``` 1. 使用在上一步中创建的根密钥对根证书进行自签名。 ``` openssl req -x509 -new -nodes -key self-rootCA.key -sha256 -days 3650 -out self-rootCA.pem ``` 使用以下输入参数： + `Country Name (2 letter code) [XX]`，例如：`AU` + `State or Province Name (full name) []`，例如：`NSW` + `Locality Name (e.g., city) [Default City]`，例如：`Sydney` + `Organization Name (e.g., company) [Default Company Ltd]`，例如：`AmazonWebService` + `Organizational Unit Name (e.g., section) []`，例如：`DBeng` + `Common Name (e.g., your name or your server's hostname) []`，例如：`aws` + `Email Address []`，例如：abcd.efgh@amazonwebservice.com 1. 为 Oracle 数据库创建 Oracle wallet 目录。 ``` mkdir -p /u01/app/oracle/wallet ``` 1. 创建新的 Oracle wallet。 ``` orapki wallet create -wallet "/u01/app/oracle/wallet" -pwd oracle123 -auto_login_local ``` 1. 将根证书添加到 Oracle wallet。 ``` orapki wallet add -wallet "/u01/app/oracle/wallet" -pwd oracle123 -trusted_cert -cert /u01/app/oracle/self_signed_cert/self-rootCA.pem ``` 1. 列出 Oracle wallet 的内容。该列表应包含根证书。 ``` orapki wallet display -wallet /u01/app/oracle/wallet -pwd oracle123 ``` 例如，这可能显示以下类似内容。 ``` Requested Certificates: User Certificates: Trusted Certificates: Subject: CN=aws,OU=DBeng,O= AmazonWebService,L=Sydney,ST=NSW,C=AU ``` 1. 使用 ORAPKI 实用程序生成证书签名请求 (CSR)。 ``` orapki wallet add -wallet "/u01/app/oracle/wallet" -pwd oracle123 -dn "CN=aws" -keysize 2048 -sign_alg sha256 ``` 1. 运行如下命令。 ``` openssl pkcs12 -in /u01/app/oracle/wallet/ewallet.p12 -nodes -out /u01/app/oracle/wallet/nonoracle_wallet.pem ``` 这会产生类似下面的输出。 ``` Enter Import Password: MAC verified OK Warning unsupported bag type: secretBag ``` 1. 将“dms”用作公用名。 ``` openssl req -new -key /u01/app/oracle/wallet/nonoracle_wallet.pem -out certdms.csr ``` 使用以下输入参数： + `Country Name (2 letter code) [XX]`，例如：`AU` + `State or Province Name (full name) []`，例如：`NSW` + `Locality Name (e.g., city) [Default City]`，例如：`Sydney` + `Organization Name (e.g., company) [Default Company Ltd]`，例如：`AmazonWebService` + `Organizational Unit Name (e.g., section) []`，例如：`aws` + `Common Name (e.g., your name or your server's hostname) []`，例如：`aws` + `Email Address []`，例如：abcd.efgh@amazonwebservice.com 请确保这与步骤 4 不同。例如，您可以通过将组织单位名称更改为其他名称来实现此目的，如下所示。 输入要随证书申请一起发送的以下其他属性。 + `A challenge password []`，例如：`oracle123` + `An optional company name []`，例如：`aws` 1. 获取证书签名。 ``` openssl req -noout -text -in certdms.csr | grep -i signature ``` 这篇文章的签名密钥是 `sha256WithRSAEncryption`。 1. 运行以下命令以生成证书（`.crt`）文件。 ``` openssl x509 -req -in certdms.csr -CA self-rootCA.pem -CAkey self-rootCA.key -CAcreateserial -out certdms.crt -days 365 -sha256 ``` 这会产生类似下面的输出。 ``` Signature ok subject=/C=AU/ST=NSW/L=Sydney/O=awsweb/OU=DBeng/CN=aws Getting CA Private Key ``` 1. 将证书添加到 wallet。 ``` orapki wallet add -wallet /u01/app/oracle/wallet -pwd oracle123 -user_cert -cert certdms.crt ``` 1. 查看 Wallet。它应该包含两个条目。请参阅以下代码。 ``` orapki wallet display -wallet /u01/app/oracle/wallet -pwd oracle123 ``` 1. 配置 `sqlnet.ora` 文件（`$ORACLE_HOME/network/admin/sqlnet.ora`）。 ``` WALLET_LOCATION = (SOURCE = (METHOD = FILE) (METHOD_DATA = (DIRECTORY = /u01/app/oracle/wallet/) ) ) SQLNET.AUTHENTICATION_SERVICES = (NONE) SSL_VERSION = 1.0 SSL_CLIENT_AUTHENTICATION = FALSE SSL_CIPHER_SUITES = (SSL_RSA_WITH_AES_256_CBC_SHA) ``` 1. 停止 Oracle 侦听器。 ``` lsnrctl stop ``` 1. 在 `listener.ora` 文件 (`$ORACLE_HOME/network/admin/listener.ora`) 中添加 SSL 条目。 ``` SSL_CLIENT_AUTHENTICATION = FALSE WALLET_LOCATION = (SOURCE = (METHOD = FILE) (METHOD_DATA = (DIRECTORY = /u01/app/oracle/wallet/) ) ) SID_LIST_LISTENER = (SID_LIST = (SID_DESC = (GLOBAL_DBNAME = SID) (ORACLE_HOME = ORACLE_HOME) (SID_NAME = SID) ) ) LISTENER = (DESCRIPTION_LIST = (DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = localhost.localdomain)(PORT = 1521)) (ADDRESS = (PROTOCOL = TCPS)(HOST = localhost.localdomain)(PORT = 1522)) (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521)) ) ) ``` 1. 配置 `tnsnames.ora` 文件（`$ORACLE_HOME/network/admin/tnsnames.ora`）。 ``` = (DESCRIPTION= (ADDRESS_LIST = (ADDRESS=(PROTOCOL = TCP)(HOST = localhost.localdomain)(PORT = 1521)) ) (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = ) ) ) _ssl= (DESCRIPTION= (ADDRESS_LIST = (ADDRESS=(PROTOCOL = TCPS)(HOST = localhost.localdomain)(PORT = 1522)) ) (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = ) ) ) ``` 1. 重新启动 Oracle 侦听器。 ``` lsnrctl start ``` 1. 显示 Oracle 侦听器状态。 ``` lsnrctl status ``` 1. 使用 sqlplus 和 SSL tnsnames 条目测试从本地主机到数据库的 SSL 连接。 ``` sqlplus -L ORACLE_USER@SID_ssl ``` 1. 验证您已使用 SSL 成功连接。 ``` SELECT SYS_CONTEXT('USERENV', 'network_protocol') FROM DUAL; SYS_CONTEXT('USERENV','NETWORK_PROTOCOL') -------------------------------------------------------------------------------- tcps ``` 1. 将目录更改为具有自签名证书的目录。 ``` cd /u01/app/oracle/self_signed_cert ``` 1. 创建一个新的客户端 Oracle 钱包 AWS DMS 以供使用。 ``` orapki wallet create -wallet ./ -auto_login_only ``` 1. 将自签名根证书添加到 Oracle wallet。 ``` orapki wallet add -wallet ./ -trusted_cert -cert self-rootCA.pem -auto_login_only ``` 1. 列出 AWS DMS 要使用的 Oracle 钱包中的内容。该列表应包含自签名根证书。 ``` orapki wallet display -wallet ./ ``` 这会产生类似下面的输出。 ``` Trusted Certificates: Subject: CN=aws,OU=DBeng,O=AmazonWebService,L=Sydney,ST=NSW,C=AU ``` 1. 将您刚刚创建的 Oracle 钱包上传到 AWS DMS。 ## 使用 Oracle 作为数据源的支持的加密方法 AWS DMS 在下表中，您可以找到使用 Oracle 源数据库时 AWS DMS 支持的透明数据加密 (TDE) 方法。 | 重做日志访问方法 | TDE 表空间 | TDE 列 | | --- | --- | --- | | 甲骨文 LogMiner | 支持 | 是 | | Binary Reader | 支持 | 是 | AWS DMS 在列级别和表空间级别使用二进制读取器时都支持 Oracle TDE。要将 TDE 加密与一起使用 AWS DMS，请先确定存储 TDE 加密密钥和 TDE 密码的 Oracle 钱包位置。然后为您的 Oracle 源端点确定正确的 TDE 加密密钥和密码。 **要识别并指定用于 TDE 加密的加密密钥和密码** 1. 运行以下查询，在 Oracle 数据库主机上查找 Oracle 加密 Wallet。 ``` SQL> SELECT WRL_PARAMETER FROM V$ENCRYPTION_WALLET; WRL_PARAMETER -------------------------------------------------------------------------------- /u01/oracle/product/12.2.0/dbhome_1/data/wallet/ ``` 在这里，`/u01/oracle/product/12.2.0/dbhome_1/data/wallet/` 是 Wallet 所在的位置。 1. 获取非 CDB 或 CDB 源的主密钥 ID，如下所示： 1. 对于非 CDB 来源，请运行以下查询来检索主加密密钥 ID： ``` SQL> select rownum, key_id, activation_time from v$encryption_keys; ROWNUM KEY_ID ACTIVATION_TIME ------ ------------------------------------------------------ --------------- 1 AeKask0XZU+NvysflCYBEVwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 04-SEP-24 10.20.56.605200 PM +00:00 2 AV7WU9uhoU8rv8daE/HNnSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 10-AUG-21 07.52.03.966362 PM +00:00 3 AckpoJ/f+k8xvzJ+gSuoVH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 14-SEP-20 09.26.29.048870 PM +00:00 ``` 如果您计划从过去的某个时候启动 CDC，则激活时间非常有用。例如，根据上述结果，您可以使用 ROWNUM 2 中的主密钥 ID 在介于 10-AUG-21 07.52.03 PM 和 14-SEP-20 09.26.29 之间的某个时间点启动 CDC。当任务到达在 14-SEP-20 09.26.29 PM 当天或之后生成的重做时，它会失败，您必须修改源端点，在 ROWNUM 3 中提供主密钥 ID，然后继续执行任务。 1. 对于 CDB 来源，DMS 需要 CDB\$1ROOT 主加密密钥。连接到 CDB\$1ROOT 并执行以下查询： ``` SQL> select rownum, key_id, activation_time from v$encryption_keys where con_id = 1; ROWNUM KEY_ID ACTIVATION_TIME ------ ---------------------------------------------------- ----------------------------------- 1 Aa2E/Vwb5U+zv5hCncS5ErMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 29-AUG-24 12.51.19.699060 AM +00:00 ``` 1. 在命令行中，列出源 Oracle 数据库主机上的加密 Wallet 条目。 ``` $ mkstore -wrl /u01/oracle/product/12.2.0/dbhome_1/data/wallet/ -list Oracle Secret Store entries: ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ORACLE.SECURITY.DB.ENCRYPTION.AY1mRA8OXU9Qvzo3idU4OH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ORACLE.SECURITY.DB.ENCRYPTION.MASTERKEY ORACLE.SECURITY.ID.ENCRYPTION. ORACLE.SECURITY.KB.ENCRYPTION. ORACLE.SECURITY.KM.ENCRYPTION.AY1mRA8OXU9Qvzo3idU4OH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ``` 找到包含您在步骤 2（`AWGDC9glSk8Xv+3bVveiVSg`）中找到的包含主密钥 ID 的条目。此条目是 TDE 加密密钥名称。 1. 查看您在上一步中找到的条目的详细信息。 ``` $ mkstore -wrl /u01/oracle/product/12.2.0/dbhome_1/data/wallet/ -viewEntry ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Oracle Secret Store Tool : Version 12.2.0.1.0 Copyright (c) 2004, 2016, Oracle and/or its affiliates. All rights reserved. Enter wallet password: ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA = AEMAASAASGYs0phWHfNt9J5mEMkkegGFiD4LLfQszDojgDzbfoYDEACv0x3pJC+UGD/PdtE2jLIcBQcAeHgJChQGLA== ``` 输入 Wallet 密码以查看结果。 在这里，`'='` 右边的值是 TDE 密码。 1. 通过设置额外连接属性 `securityDbEncryptionName` 为 Oracle 源端点指定 TDE 加密密钥名称。 ``` securityDbEncryptionName=ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ``` 1. 在控制台上提供此密钥的关联 TDE 密码，将其作为 Oracle 源的**密码**值的一部分。按以下顺序设置以逗号分隔的密码值的格式，以 TDE 密码值结尾。 ``` Oracle_db_password,ASM_Password,AEMAASAASGYs0phWHfNt9J5mEMkkegGFiD4LLfQszDojgDzbfoYDEACv0x3pJC+UGD/PdtE2jLIcBQcAeHgJChQGLA== ``` 无论 Oracle 数据库配置如何，都按此顺序指定密码值。例如，如果您使用的是 TDE，但 Oracle 数据库未使用 ASM，请按照以下逗号分隔顺序指定密码值。 ``` Oracle_db_password,,AEMAASAASGYs0phWHfNt9J5mEMkkegGFiD4LLfQszDojgDzbfoYDEACv0x3pJC+UGD/PdtE2jLIcBQcAeHgJChQGLA== ``` 如果您指定的 TDE 凭证不正确，则 AWS DMS 迁移任务不会失败。但是，该任务也不会读取持续复制更改或将其应用到目标数据库。启动任务后，在控制台迁移任务页面上监控**表统计数据**，确保已复制更改。 如果数据库管理员在运行任务时更改 Oracle 数据库的 TDE 凭证值，任务会失败。错误消息中包含新的 TDE 加密密钥名称。要指定新值并重新启动任务，请使用前面的步骤。 **重要** 您无法操作在 Oracle Automatic Storage Management（ASM）所在位置创建的 TDE Wallet，因为操作系统级别的命令（例如 `cp`、`mv`、`orapki` 和 `mkstore`）会损坏存储在 ASM 所在位置的 Wallet 文件。此限制仅适用于只存储在 ASM 所在位置的 TDE Wallet 文件，但不适用于存储在本地操作系统目录中的 TDE Wallet 文件。 要使用操作系统级别的命令操作存储在 ASM 中的 TDE Wallet，请创建本地密钥库，并按如下方式将 ASM 密钥库合并到本地密钥库中： 创建本地密钥库。 ``` ADMINISTER KEY MANAGEMENT create keystore file system wallet location identified by wallet password; ``` 将 ASM 密钥库合并到本地密钥库中。 ``` ADMINISTER KEY MANAGEMENT merge keystore ASM wallet location identified by wallet password into existing keystore file system wallet location identified by wallet password with backup; ``` 然后，要列出加密 Wallet 条目和 TDE 密码，请对本地密钥库运行步骤 3 和 4。 ## 使用 Oracle 作为源时支持的压缩方法 AWS DMS 在下表中，您可以找到使用 Oracle 源数据库时 AWS DMS 支持的压缩方法。如表所示，压缩支持取决于您的 Oracle 数据库版本以及 DMS 是否配置为使用 Oracle LogMiner 访问重做日志。 | 版本 | Basic | OLTP | HCC（来自 Oracle 11g R2 或更高版本） | 其他 | | --- | --- | --- | --- | --- | | Oracle 10 | 否 | 不适用 | 不适用 | 否 | | 甲骨文 11 或更高版本 — 甲骨文 LogMiner | 支持 | 是 | 是 | 是 — Oracle 支持的任何压缩方法 LogMiner。 | | Oracle 11 或更高版本 – Binary Reader | 支持 | 是 | 是 – 有关更多信息，请参阅以下注释。 | 是 | **注意** 当 Oracle 源终端节点配置为使用 Binary Reader 时，只有满载任务才支持 HCC 压缩方法的查询低级别。 ## 使用 Oracle 作为源来复制嵌套表 AWS DMS AWS DMS 支持复制包含嵌套表或定义类型的列的 Oracle 表。要启用此功能，请将以下额外连接属性设置添加到 Oracle 源端点。 ``` allowSelectNestedTables=true; ``` AWS DMS 从 Oracle 嵌套表中创建目标表，作为目标上的常规父表和子表，没有唯一约束。要访问目标上的正确数据，请联接父表和子表。为此，首先在目标子表中的 `NESTED_TABLE_ID` 列上手动创建非唯一索引。然后，您可以将 `ON` 联接子句中的 `NESTED_TABLE_ID` 列与子表名称对应的父列一起使用。此外，通过更新或删除目标子表数据时，创建这样的索引可以提高性能 AWS DMS。有关示例，请参阅[目标上的父表和子表联接示例](#CHAP_Source.Oracle.NestedTables.JoinExample)。 我们建议您将任务配置为在满载完成后停止。然后，为目标上的所有复制子表创建这些非唯一索引，然后恢复任务。 如果将捕获的嵌套表添加到现有的父表中（捕获或未捕获），请正确 AWS DMS 处理该表。但是，不会创建相应目标表的非唯一索引。在此情况下，如果目标子表变得非常大，性能可能会受到影响。在这种情况下，我们建议您停止任务，创建索引，然后再恢复任务。 在嵌套表复制到目标后，让 DBA 运行父表和相应子表上的联接以平展数据。 ### 将 Oracle 嵌套表复制为源的先决条件 确保复制所有复制的嵌套表的父表。在表映射中同时包括父表（包含嵌套表列的表）和子表（即嵌套）。 AWS DMS ### 支持的 Oracle 嵌套表类型作为源 AWS DMS 支持以下 Oracle 嵌套表类型作为源： + 数据类型 + 用户定义的对象 ### AWS DMS 支持 Oracle 嵌套表作为源的局限性 AWS DMS 在支持 Oracle 嵌套表作为源方面存在以下限制： + AWS DMS 仅支持一层表嵌套。 + AWS DMS 表映射不检查是否同时选择父表和子表或表进行复制。也就是说，可以选择没有子表的父表或没有父表的子表。 ### 如何将 Oracle 嵌套表作为 AWS DMS 源复制 AWS DMS 将父表和嵌套表复制到目标表，如下所示： + AWS DMS 创建与源表相同的父表。然后，它将父表中的嵌套列定义为 `RAW(16)`，并在其 `NESTED_TABLE_ID` 列中包含对父表的嵌套表的引用。 + AWS DMS 创建与嵌套源相同的子表，但还有一个名为的附加列`NESTED_TABLE_ID`。此列的类型和值与相应的父嵌套列相同，含义也相同。 ### 目标上的父表和子表联接示例 要平展父表，请运行父表和子表之间的联接，如以下示例所示： 1. 创建 `Type` 表。 ``` CREATE OR REPLACE TYPE NESTED_TEST_T AS TABLE OF VARCHAR(50); ``` 1. 使用前面定义的列（类型为 `NESTED_TEST_T`）列创建父表。 ``` CREATE TABLE NESTED_PARENT_TEST (ID NUMBER(10,0) PRIMARY KEY, NAME NESTED_TEST_T) NESTED TABLE NAME STORE AS NAME_KEY; ``` 1. 通过对其 `CHILD.NESTED_TABLE_ID` 与 `PARENT.NAME` 匹配的 `NAME_KEY` 子表使用联接来平展表 `NESTED_PARENT_TEST`。 ``` SELECT … FROM NESTED_PARENT_TEST PARENT, NAME_KEY CHILD WHERE CHILD.NESTED_ TABLE_ID = PARENT.NAME; ``` ## 使用 Oracle 作为源时在 Oracle ASM 上存储 REDO AWS DMS 对于 REDO 生成量较高的 Oracle 源，在 Oracle ASM 上存储 REDO 可以提高性能，尤其是在 RAC 配置中，因为您可以将 DMS 配置为跨所有 ASM 节点分配 ASM REDO 读取。 要使用此配置，请使用 `asmServer` 连接属性。例如，以下连接字符串将跨 3 个 ASM 节点分配 DMS REDO 读取： ``` asmServer=(DESCRIPTION=(CONNECT_TIMEOUT=8)(ENABLE=BROKEN)(LOAD_BALANCE=ON)(FAILOVER=ON) (ADDRESS_LIST= (ADDRESS=(PROTOCOL=tcp)(HOST=asm_node1_ip_address)(PORT=asm_node1_port_number)) (ADDRESS=(PROTOCOL=tcp)(HOST=asm_node2_ip_address)(PORT=asm_node2_port_number)) (ADDRESS=(PROTOCOL=tcp)(HOST=asm_node3_ip_address)(PORT=asm_node3_port_number))) (CONNECT_DATA=(SERVICE_NAME=+ASM))) ``` 使用 NFS 存储 Oracle REDO 时，请务必确保应用了适用的 DNFS（Direct NFS）客户端补丁，特别是解决 Oracle 错误 25224242 的任何补丁。有关更多信息，请查阅以下有关 Direct NFS Client 相关补丁的 Oracle 出版物 [Direct NFS Client 的推荐补丁](https://support.oracle.com/knowledge/Oracle Cloud/1495104_1.html)。 此外，为了提高 NFS 读取性能，我们建议您增加 NFS 卷的 `fstab` 中的 `rsize` 和 `wsize` 的值，如以下示例所示。 ``` NAS_name_here:/ora_DATA1_archive /u09/oradata/DATA1 nfs rw,bg,hard,nointr,tcp,nfsvers=3,_netdev, timeo=600,rsize=262144,wsize=262144 ``` 另外，按如下方式调整 `tcp-max-xfer-size` 值： ``` vserver nfs modify -vserver vserver -tcp-max-xfer-size 262144 ``` ## 使用 Oracle 作为来源时的终端节点设置 AWS DMS 您可以使用端点设置来配置 Oracle 源数据库，这与使用额外连接属性类似。您可以在使用 AWS DMS 控制台创建源端点时指定设置，或者使用中带有 `--oracle-settings '{"EndpointSetting": "value", ...}'` JSON 语法的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)命令来指定设置。 下表显示了将 Oracle 用作源时可以使用的端点设置。 | Name | 说明 | | --- | --- | | AccessAlternateDirectly | 将此属性设置为 false，以便使用 Binary Reader 捕获作为源的 Amazon RDS for Oracle 的更改数据。这将指示 DMS 实例不要使用直接文件访问通过任何指定的路径前缀替换来访问重做日志。有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。 默认值：true 有效值：true/false 示例：`--oracle-settings '{"AccessAlternateDirectly": false}'` | | `AdditionalArchivedLogDestId` | 在主/备用设置中将此属性与 `ArchivedLogDestId` 一起设置。当您使用 Oracle Data Guard 数据库作为源时，此属性在切换中非常有用。在这种情况下， AWS DMS 需要知道从哪个目的地获取存档重做日志以读取更改。这是因为之前的主实例现在是切换后的备用实例。 尽管 AWS DMS 支持使用 Oracle `RESETLOGS` 选项打开数据库，但`RESETLOGS`除非必要，否则切勿使用。有关 `RESETLOGS` 的其他信息，请参阅《Oracle® 数据库备份和还原用户指南》**中的 [RMAN 数据修复概念](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/rman-data-repair-concepts.html#GUID-1805CCF7-4AF2-482D-B65A-998192F89C2B)。 有效值：存档目标 ID 示例：`--oracle-settings '{"AdditionalArchivedLogDestId": 2}'` | | `AddSupplementalLogging` | 设置此属性可设置 Oracle 数据库的表级别补充日志记录。根据表元数据的不同，此属性可在为迁移任务选择的所有表上启用以下操作之一： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.Oracle.html) 默认值：false 有效值： true/false 示例：`--oracle-settings '{"AddSupplementalLogging": false}'` 如果您使用此选项，则仍需启用前面讨论过的数据库级别补充日志记录。 | | `AllowSelectNestedTables` | 将此属性设置为 true 可复制包含作为嵌套表或已定义类型的列的 Oracle 表。有关更多信息，请参阅 [使用 Oracle 作为源来复制嵌套表 AWS DMS](#CHAP_Source.Oracle.NestedTables)。 默认值：false 有效值：true/false 示例：`--oracle-settings '{"AllowSelectNestedTables": true}'` | | `ArchivedLogDestId` | 指定已存档重做日志的目标的 ID。该值应与 v\$1archived\$1log 视图的 dest\$1id 列中的数相同。如果您使用其他重做日志目标，建议您使用 `AdditionalArchivedLogDestId` 属性来指定其他目标 ID。这样做将确保从一开始便访问正确的日志，从而提高性能。 默认值：1 有效值：数字 示例：`--oracle-settings '{"ArchivedLogDestId": 1}'` | | `ArchivedLogsOnly` | 当此字段设置为 Y 时， AWS DMS 仅访问已存档的重做日志。如果存档的重做日志仅存储在 Oracle ASM 上，则需要向 AWS DMS 用户帐户授予 ASM 权限。 默认值：N 有效值： Y/N 示例：`--oracle-settings '{"ArchivedLogsOnly": Y}'` | | `asmUsePLSQLArray`（仅限 ECA） | 使用捕获源更改时，请使用此额外连接属性 (ECA) BinaryReader。此设置允许 DMS 在 ASM 级别为每个读取线程缓冲 50 次读取，同时使用 `parallelASMReadThreads` 属性控制线程的数量。设置此属性时， AWS DMS 二进制读取器使用匿名 PL/SQL 块来捕获重做数据并将其作为大型缓冲区发送回复制实例。这减少了往返源的次数。这可以显著提高源捕获性能，但确实会导致 ASM 实例上的 PGA 内存消耗增加。如果内存目标不足，可能会出现稳定性问题。您可以使用以下公式，估算单个 DMS 任务的 ASM 实例 PGA 内存使用总量：`number_of_redo_threads * parallelASMReadThreads * 7 MB` 默认值：false 有效值：true/false ECA 示例：`asmUsePLSQLArray=true;` | | `ConvertTimestampWithZoneToUTC` | 将此属性设置为 `true`，以便将“TIMESTAMP WITH TIME ZONE”和“TIMESTAMP WITH LOCAL TIME ZONE”列的时间戳值转换为 UTC。默认情况下，此属性的值为“false”，数据将使用源数据库时区进行复制。 默认值：false 有效值：true/false 示例：`--oracle-settings '{"ConvertTimestampWithZoneToUTC": true}'` | | `EnableHomogenousPartitionOps` | 将此属性设置为 `true`，以便为 Oracle *同构*迁移启用 Oracle 分区和子分区 DDL 操作的复制。 请注意，此功能和增强功能已在 3.4.7 AWS DMS 版本中引入。 默认值：false 有效值：true/false 示例：`--oracle-settings '{"EnableHomogenousPartitionOps": true}'` | | `EnableHomogenousTablespace` | 将此属性设置为启用同类表空间复制，并在目标上的相同表空间下创建现有的表或索引。 默认值：false 有效值：true/false 示例：`--oracle-settings '{"EnableHomogenousTablespace": true}'` | | `EscapeCharacter` | 将此属性设置为转义字符。此转义字符允许您在表映射表达式中将单个通配符用作一个普通字符。有关更多信息，请参阅 [表映射中的通配符](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)。 默认值：Null 有效值：除通配符之外的任何字符 示例：`--oracle-settings '{"EscapeCharacter": "#"}'` 您只能将 `escapeCharacter` 用于表名。它不会对架构名或列名中的字符进行转义。 | | `ExposeViews` | 使用此属性可从视图中提取一次数据；您无法将其用于持续复制。从视图中提取数据时，此视图将显示为目标架构上的表。 默认值：false 有效值：true/false 示例：`--oracle-settings '{"ExposeViews": true}'` | | `ExtraArchivedLogDestIds` | 为 IDs 一个或多个已存档的重做日志指定一个或多个目标。这些 IDs 是 v\$1archived\$1log 视图中 dest\$1id 列的值。在设置或设置中将此 primary-to-single设置与 ArchivedLogDestId 额外的连接属性一起 primary-to-multiple-standby使用。 当您使用 Oracle Data Guard 数据库作为源时，此设置在切换中非常有用。在这种情况下， AWS DMS 需要有关从哪个目的地获取存档重做日志以读取更改的信息。 AWS DMS 需要这个，因为在切换之后，之前的主实例是备用实例。 有效值：存档目标 ID 示例：`--oracle-settings '{"ExtraArchivedLogDestIds": 1}'` | | `FailTasksOnLobTruncation` | 当设置为 `true` 时，如果 LOB 列的实际大小大于指定的 `LobMaxSize`，此属性将导致任务失败。 如果任务设置为受限 LOB 模式并且此选项设置为 `true`，任务将失败，而不是截断 LOB 数据。 默认值：false 有效值：布尔值 示例：`--oracle-settings '{"FailTasksOnLobTruncation": true}'` | | `filterTransactionsOfUser`（仅限 ECA） | 使用此额外连接属性 (ECA) 允许 DMS 在使用时从 Oracle 复制数据时忽略来自指定用户的事务。 LogMiner您可以传递以逗号分隔的用户名值，但这些值必须全部使用大写字母。 ECA 示例：`filterTransactionsOfUser=USERNAME;` | | `NumberDataTypeScale` | 指定数字的小数位数。可以选择最大为 38 的小数位数，也可以选择 -1（对于 FLOAT）或 -2（VARCHAR）。默认情况下，NUMBER 数据类型将转换为精度 38，小数位数 10。 默认值：10 有效值：-2 到 38（对于 VARCHAR 为 -2，对于 FLOAT 为 -1） 示例：`--oracle-settings '{"NumberDataTypeScale": 12}'` 选择精度小数位数组合，即 -1（FLOAT）或 -2（VARCHAR）。DMS 支持 Oracle 支持的任何精度小数位数组合。如果精度大于等于 39，请选择 -2（VARCHAR）。Oracle 数据库的 NumberDataTypeScale 设置仅用于 NUMBER 数据类型（没有明确的精度和小数位数定义）。必须注意，如果此设置配置不正确，可能会导致精度损失。 | | `OpenTransactionWindow` | 提供为仅 CDC 的任务检查任何未结事务的时间范围（以分钟为单位）。 当您将 `OpenTransactionWindow` 设置为 1 或更高时，DMS 使用 `SCN_TO_TIMESTAMP` 将 SCN 值转换为时间戳值。由于 Oracle 数据库限制，如果您指定过旧的 SCN 作为 CDC 开始点，则 SCN\$1TO\$1TIMESTAMP 将失败并显示 `ORA-08181` 错误，并且您无法启动仅 CDC 任务。 默认值：0 有效值：从 0 到 240 的整数 示例：`openTransactionWindow=15;` | | OraclePathPrefix | 将此字符串属性设置为必需值，以便使用 Binary Reader 捕获作为源的 Amazon RDS for Oracle 的更改数据。此值指定用于访问重做日志的默认 Oracle root。有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。默认值：none 有效值：/rdsdbdata/db/ORCL\$1A/ 示例：`--oracle-settings '{"OraclePathPrefix": "/rdsdbdata/db/ORCL_A/"}'` | | ParallelASMReadThreads | 设置此属性可更改 DMS 配置通过 Oracle Automatic Storage Management（ASM）执行更改数据捕获（CDC）所用的线程数。您可以指定一个介于 2（默认值）和 8（最大值）之间的整数值。将此属性与 `ReadAheadBlocks` 属性一起使用。有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。 默认值：2 有效值：从 2 到 8 的整数 示例：`--oracle-settings '{"ParallelASMReadThreads": 6;}'` | | ReadAheadBlocks | 设置此属性可更改 DMS 配置通过 Oracle Automatic Storage Management（ASM）和非 ASM NAS 存储执行更改数据捕获（CDC）所用的预读数据块数。您可以指定介于 1000（默认值）和 2,000,000（最大值）之间的整数值。将此属性与 `ParallelASMReadThreads` 属性一起使用。有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。 默认值：1000 有效值：介于 1000 到 2,000,000 之间的整数 示例：`--oracle-settings '{"ReadAheadBlocks": 150000}'` | | `ReadTableSpaceName` | 当设置为 `true` 时，此属性支持表空间复制。 默认值：false 有效值：布尔值 示例：`--oracle-settings '{"ReadTableSpaceName": true}'` | | ReplacePathPrefix | 将此属性设置为 true，以便使用 Binary Reader 捕获作为源的 Amazon RDS for Oracle 的更改数据。此设置指示 DMS 实例使用指定的 UsePathPrefix 设置替换默认的 Oracle root，以访问重做日志。有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。默认值：false 有效值：true/false 示例：`--oracle-settings '{"ReplacePathPrefix": true}'` | | `RetryInterval` | 指定系统在重新发送查询之前等待的秒数。 默认值：5 有效值：从 1 开始的数字 示例：`--oracle-settings '{"RetryInterval": 6}'` | | `SecurityDbEncryptionName` | 指定一个密钥的名称，该密钥用于对 Oracle 源数据库中的列和表空间进行透明数据加密 (TDE)。有关在 Oracle 源终端节点上设置此属性及其关联密码的更多信息，请参阅[使用 Oracle 作为数据源的支持的加密方法 AWS DMS](#CHAP_Source.Oracle.Encryption)。 默认值："" 有效值：字符串 示例：`--oracle-settings '{"SecurityDbEncryptionName": "ORACLE.SECURITY.DB.ENCRYPTION.Adg8m2dhkU/0v/m5QUaaNJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"}'` | | `SpatialSdo2GeoJsonFunctionName` | 对于迁移到 PostgreSQL 目标的 Oracle 12.1 版或更早版本的源，请使用此属性将 SDO\$1GEOMETRY 格式转换为 GEOJSON 格式。 默认情况下， AWS DMS 调用`SDO2GEOJSON`自定义函数，该函数必须存在且 AWS DMS 用户可以访问。或者，您也可以自行创建模仿 `SDOGEOJSON` 操作的自定义函数，并设置 `SpatialSdo2GeoJsonFunctionName` 以改为调用它。 默认值： SDO2GEOJSON 有效值：字符串 示例：`--oracle-settings '{"SpatialSdo2GeoJsonFunctionName": "myCustomSDO2GEOJSONFunction"}'` | | `StandbyDelayTime` | 使用此属性指定备用同步延迟时间 (以分钟为单位)。如果源是 Active Data Guard 备用数据库，请使用此属性指定主数据库和备用数据库之间的时间滞后。 在中 AWS DMS，您可以创建一个 Oracle CDC 任务，该任务使用 Active Data Guard 备用实例作为复制正在进行的更改的来源。这样一来，便无需连接到可能处于生产状态的活动数据库。 默认值：0 有效值：数字 示例：`--oracle-settings '{"StandbyDelayTime": 1}'` **注意：**使用 DMS 3.4.6、3.4.7 及更高版本时，可以选用此连接设置。在最新版本的 DMS 3.4.6 和 3.4.7 中，`dms_user` 应具有 `V_$DATAGUARD_STATS` 的 `select` 权限，这样才能允许 DMS 计算待机延迟时间。 | | UseAlternateFolderForOnline | 将此属性设置为 true，以便使用 Binary Reader 捕获作为源的 Amazon RDS for Oracle 的更改数据。这将指示 DMS 实例使用任何指定的前缀替换来访问所有在线重做日志。有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。默认值：false 有效值：true/false 示例：`--oracle-settings '{"UseAlternateFolderForOnline": true}'` | | UseBfile | 将此属性设置为 Y，以便使用 Binary Reader 实用程序捕获更改数据。将 `UseLogminerReader` 设置为 N 可将此属性设置为 Y。要在将 Amazon RDS for Oracle 作为源时使用 Binary Reader，请设置其他属性。有关此设置以及使用 Oracle Automatic Storage Management (ASM) 的更多信息，请参阅[在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器](#CHAP_Source.Oracle.CDC)。 注意：将此值设置为额外连接属性（ECA）时，有效值为“Y”和“N”。将此值设置为端点设置时，有效值为 `true` 和 `false`。 默认值：N 有效值： Y/N （将此值设置为 ECA 时）； true/false （将此值设置为端点设置时）。 示例：`--oracle-settings '{"UseBfile": Y}'` | | `UseLogminerReader` | 将此属性设置为 Y 以使用 LogMiner 实用程序（默认）捕获变更数据。如果希望 AWS DMS 将重做日志作为二进制文件进行访问，请将此选项设置为 N。将此选项设置为 N 时，还要添加设置 useBfile=Y。有关此设置和使用 Oracle Automatic Storage Management（ASM）的更多信息，请参阅[在 CDC 中使用 Oracle LogMiner 或 AWS DMS 二进制阅读器](#CHAP_Source.Oracle.CDC)。 注意：将此值设置为额外连接属性（ECA）时，有效值为“Y”和“N”。将此值设置为端点设置时，有效值为 `true` 和 `false`。 默认值：Y 有效值： Y/N （将此值设置为 ECA 时）； true/false （将此值设置为端点设置时）。 示例：`--oracle-settings '{"UseLogminerReader": Y}'` | | UsePathPrefix | 将此字符串属性设置为必需值，以便使用 Binary Reader 捕获作为源的 Amazon RDS for Oracle 的更改数据。此值指定用于替换访问重做日志的默认 Oracle root 的路径前缀。有关更多信息，请参阅 [将 CDC 任务配置为将二进制读取器与 RDS for Oracle 源一起使用 AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC)。默认值：none 有效值：/rdsdbdata/log/ 示例：`--oracle-settings '{"UsePathPrefix": "/rdsdbdata/log/"}'` | ## Oracle 的源数据类型 的 Oracle 终端节点 AWS DMS 支持大多数 Oracle 数据类型。下表显示了使用时支持的 Oracle 源数据类型 AWS DMS 以及与 AWS DMS 数据类型的默认映射。 **注意** 除了 LONG 和 LONG RAW 数据类型之外，从 Oracle 源复制到 Oracle 目标（*同构复制*）时，所有源数据类型和目标数据类型都相同。但是 LONG 数据类型将映射到 CLOB，LONG RAW 数据类型将映射到 BLOB。 有关如何查看目标中映射的数据类型的信息，请参阅有关所使用的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | Oracle 数据类型 | AWS DMS 数据类型 | | --- | --- | | BINARY\$1FLOAT | REAL4 | | BINARY\$1DOUBLE | REAL8 | | BINARY | BYTES | | FLOAT (P) | 如果精度小于或等于 24，请使用 REAL4。 如果精度大于 24，则使用 REAL8。 | | NUMBER (P,S) | 当小数位数大于 0 时，请使用 NUMERIC。 当小数位数为 0 时： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.Oracle.html) 当比例小于 0 时，使用 REAL8。 | | DATE | DATETIME | | INTERVAL\$1YEAR TO MONTH | STRING (带 interval year\$1to\$1month 指示) | | INTERVAL\$1DAY TO SECOND | STRING (带 interval day\$1to\$1second 指示) | | TIMESTAMP | DATETIME | | TIMESTAMP（有时区） | STRING (带 timestamp\$1with\$1timezone 指示) | | 带本地时区的 TIMESTAMP | STRING (带 timestamp\$1with\$1local\$1 timezone 指示) | | CHAR | string | | VARCHAR2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.Oracle.html) | | NCHAR | WSTRING | | NVARCHAR2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.Oracle.html) | | RAW | BYTES | | REAL | REAL8 | | BLOB | BLOB 要将此数据类型与一起使用 AWS DMS，必须允许将 BLOB 数据类型用于特定任务。 AWS DMS 仅在包含主键的表中支持 BLOB 数据类型。 | | CLOB | CLOB 要将此数据类型与一起使用 AWS DMS，必须为特定任务启用 CLOB 数据类型。在 CDC 期间，仅在包含主键的表中 AWS DMS 支持 CLOB 数据类型。 | | NCLOB | NCLOB 要将此数据类型与一起使用 AWS DMS，必须允许将 NCLOB 数据类型用于特定任务。在 CDC 期间，仅在包含主键的表中 AWS DMS 支持 NCLOB 数据类型。 | | LONG | CLOB 批量优化应用模式（TurboStream CDC 模式）不支持 LONG 数据类型。 要将此数据类型与一起使用 AWS DMS，请 LOBs 为特定任务启用使用。 在 CDC 或满载期间，仅在具有主键的表中 AWS DMS 支持 LOB 数据类型。 此外， AWS DMS 不支持用于加载长列的完整 LOB 模式。但您可以使用受限的 LOB 模式将 LONG 列迁移到 Oracle 目标。在受限 LOB 模式下，将您设置为长度超过 64 KB 的长列的所有数据 AWS DMS 截断为 64 KB。有关中 LOB 支持的更多信息 AWS DMS，请参阅 [在任务中为源数据库设置 LOB 支持 AWS DMS](CHAP_Tasks.LOBSupport.md) | | LONG RAW | BLOB 批量优化应用模式（TurboStream CDC 模式）不支持 LONG RAW 数据类型。 要将此数据类型与一起使用 AWS DMS，请 LOBs 为特定任务启用使用。 在 CDC 或满载期间，仅在具有主键的表中 AWS DMS 支持 LOB 数据类型。 此外， AWS DMS 不支持用于加载 LONG RAW 列的完整 LOB 模式。但您可以使用受限 LOB 模式将 LONG RAW 列迁移到 Oracle 目标。在受限 LOB 模式下， AWS DMS 将设置长度超过 64 KB 的 LONG RAW 列的所有数据截断为 64 KB。有关中 LOB 支持的更多信息 AWS DMS，请参阅 [在任务中为源数据库设置 LOB 支持 AWS DMS](CHAP_Tasks.LOBSupport.md) | | XMLTYPE | CLOB | | SDO\$1GEOMETRY | BLOB（当 Oracle 迁移到 Oracle 时）CLOB（当 Oracle 迁移到 PostgreSQL 时） | 作为源的 Oracle 表，带不受支持且无法复制的以下数据类型的列。复制带这些数据类型的列会生成 null 列。 + BFILE + ROWID + REF + UROWID + 用户定义的数据类型 + ANYDATA + VARRAY **注意** 不支持虚拟列。 ### 迁移 Oracle 空间数据类型 *空间数据* 可识别空间中对象或位置的几何信息。在 Oracle 数据库中，空间对象的几何描述存储在 SDO\$1GEOMETRY 类型的对象中。在此对象中，几何描述存储在用户定义表的单列中的单行中。 AWS DMS 支持将 Oracle 类型 SDO\$1GEOMETRY 从 Oracle 源迁移到 Oracle 或 PostgreSQL 目标。 使用迁移 Oracle 空间数据类型时 AWS DMS，请注意以下注意事项： + 迁移到 Oracle 目标时，请确保手动传输包含类型信息的 USER\$1SDO\$1GEOM\$1METADATA 条目。 + 从 Oracle 源端点迁移到 PostgreSQL 目标端点时 AWS DMS ，会创建目标列。这些列具有默认的几何和地理类型信息，其 2D 维度和空间参考标识符 (SRID) 等于零 (0)。例如，`GEOMETRY, 2, 0`。 + 对于迁移到 PostgreSQL 目标的 Oracle 12.1 版或更早版本的源，请使用 `SDO2GEOJSON` 函数或 `spatialSdo2GeoJsonFunctionName` 额外的连接属性，将 `SDO_GEOMETRY` 对象转换为 `GEOJSON` 格式。有关更多信息，请参阅 [使用 Oracle 作为来源时的终端节点设置 AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)。 + AWS DMS 仅在完整 LOB 模式下支持 Oracle 空间列迁移。 AWS DMS 不支持受限 LOB 或内联 LOB 模式。有关 LOB 模式的更多信息，请参阅[在任务中为源数据库设置 LOB 支持 AWS DMS](CHAP_Tasks.LOBSupport.md)。 + 由于 AWS DMS 仅支持用于迁移 Oracle Spatial Columns 的完整 LOB 模式，因此列的表需要主键和唯一键。如果表没有主键和唯一键，在迁移时会跳过此表。 # 使用微软 SQL Server 数据库作为来源 AWS DMS 使用迁移一个或多个 Microsoft SQL Server 数据库中的数据 AWS DMS。使用 SQL Server 数据库作为源，您可以将数据迁移到另一个 SQL Server 数据库或其他 AWS DMS 支持的数据库中。 有关 AWS DMS 支持作为源的 SQL Server 版本的信息，请参见[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 源 SQL Server 数据库可安装在您网络中的任意计算机上。在与 AWS DMS一起使用时，需要 SQL Server 账户，该账户对源数据库具有与选定任务类型相对应的访问权限。有关更多信息，请参阅 [SQL Server 任务权限](#CHAP_Source.SQLServer.Permissions)。 AWS DMS 支持从 SQL Server 的命名实例迁移数据。当您创建源终端节点时，您可以在服务器名称中使用以下表示法。 ``` IPAddress\InstanceName ``` 例如，以下是正确的源终端节点服务器名称。在这里，名称的第一部分是服务器的 IP 地址，第二部分是 SQL Server 实例名称（在本示例中为 SQLTest）。 ``` 10.0.0.25\SQLTest ``` 此外，请获取您的命名 SQL Server 实例监听的端口号，然后使用它来配置您的 AWS DMS 源端点。 **注意** 端口 1433 是 Microsoft SQL Server 的默认端口。但是，也经常使用每次启动 SQL Server 时更改的动态端口，以及用于通过防火墙连接到 SQL Server 的特定静态端口号。因此，在创建 AWS DMS 源端点时，您想知道命名的 SQL Server 实例的实际端口号。 可以使用 SSL 加密 SQL Server 终端节点与复制实例之间的连接。有关将 SSL 用于 SQL Server 终端节点的更多信息，请参阅[将 SSL 与 AWS Database Migration Service](CHAP_Security.SSL.md)。 您可以使用 CDC 从 SQL Server 数据库进行持续迁移。有关为 CDC 配置源 SQL Server 数据库的信息，请参阅[捕获数据更改，以便从 SQL Server 进行持续复制](CHAP_Source.SQLServer.CDC.md)。 有关使用 SQL Server 源数据库和的更多详细信息 AWS DMS，请参阅以下内容。 **Topics** + [使用 SQL Server 作为源代码的限制 AWS DMS](#CHAP_Source.SQLServer.Limitations) + [SQL Server 任务权限](#CHAP_Source.SQLServer.Permissions) + [在 SQL Server 源中使用持续复制（CDC）的先决条件](#CHAP_Source.SQLServer.Prerequisites) + [支持的 SQL Server 压缩方法](#CHAP_Source.SQLServer.Compression) + [使用自行管理的 SQL Server AlwaysOn 可用性组](#CHAP_Source.SQLServer.AlwaysOn) + [使用 SQL Server 作为源时的端点设置 AWS DMS](#CHAP_Source.SQLServer.ConnectionAttrib) + [SQL Server 的源数据类型](#CHAP_Source.SQLServer.DataTypes) + [捕获数据更改，以便从 SQL Server 进行持续复制](CHAP_Source.SQLServer.CDC.md) ## 使用 SQL Server 作为源代码的限制 AWS DMS 将 SQL Server 数据库作为 AWS DMS源时，存在以下限制： + 列的身份属性不迁移到目标数据库列。 + SQL Server 端点不支持使用包含稀疏列的表。 + 不支持 Windows 身份验证。 + 不复制对 SQL Server 中计算字段的更改。 + 不支持临时表。 + 不支持 SQL Server 分区切换。 + 使用 WRITETEXT 和 UPDATETEXT 实用程序时， AWS DMS 不会捕获应用于源数据库的事件。 + 不支持以下数据操作语言（DML）模式。 ``` SELECT * INTO new_table FROM existing_table ``` + 在将 SQL Server 作为源时，不支持列级别加密。 + AWS DMS 不支持将 SQL Server 2008 或 SQL Server 2008 R2 作为来源进行服务器级审计。这是因为 SQL Server 2008 和 2008 R2 存在已知问题。例如，运行以下命令会 AWS DMS 导致失败。 ``` USE [master] GO ALTER SERVER AUDIT [my_audit_test-20140710] WITH (STATE=on) GO ``` + 使用 SQL Server 作为源时，在完全 Lob 模式下不支持几何列和地理列。应改用受限 LOB 模式，或将 `InlineLobMaxSize` 任务设置设为使用内联 LOB 模式。 + 在复制任务中使用 Microsoft SQL Server 源数据库时，如果删除该任务，则不会删除 SQL Server Replication Publisher 定义。Microsoft SQL Server 系统管理员必须从 Microsoft SQL Server 删除这些定义。 + 仅限满载的任务支持从架构绑定和 non-schema-bound视图迁移数据。 + 不支持使用 sp\$1rename 重命名表（例如，`sp_rename 'Sales.SalesRegion', 'SalesReg;)` + 不支持使用 sp\$1rename 重命名列（例如，`sp_rename 'Sales.Sales.Region', 'RegID', 'COLUMN';`） + AWS DMS 不支持更改处理以设置和取消设置列默认值（使用带`ALTER TABLE`语`ALTER COLUMN SET DEFAULT`句的子句）。 + AWS DMS 不支持通过更改处理来设置列可为空性（使用带`ALTER TABLE`语`ALTER COLUMN [SET|DROP] NOT NULL`句的子句）。 + 在 SQL Server 2012 和 SQL Server 2014 中，将 DMS 复制与可用性组一起使用时，无法将分发数据库放入可用性组。SQL 2016 支持将分发数据库放入可用性组中，但合并、双向或 peer-to-peer复制拓扑中使用的分布数据库除外。 + 对于分区表， AWS DMS 不支持为每个分区设置不同的数据压缩设置。 + 将值插入 SQL Server 空间数据类型（GEOGRAPHY 和 GEOMETRY）时，可以忽略空间参考系统标识符（SRID）属性或指定其他数字。复制具有空间数据类型的表时， AWS DMS 将 SRID 替换为默认 SRID（几何为 0，地理位置为 4326）。 + 如果您的数据库未配置 MS-REPLICATION 或 MS-CDC，您仍然可以捕获没有主键的表，但只能捕获 INSERT/DELETE DML 事件。将忽略 UPDATE 和 TRUNCATE TABLE 事件。 + 不支持列存储索引。 + 不支持内存优化表（使用内存中 OLTP）。 + 当复制主键由多个列组成的表时，不支持在完全加载期间更新主键列。 + 不支持延迟的耐久性。 + 由于 RDS 执行备份的方式，`readBackupOnly=true` 端点设置（额外连接属性）在 RDS for SQL Server 源实例上不起作用。 + `EXCLUSIVE_AUTOMATIC_TRUNCATION` 在 Amazon RDS SQL Server 源实例上不起作用，因为 RDS 用户无权运行 SQL Server 存储过程 `sp_repldone`。 + AWS DMS 不捕获截断命令。 + AWS DMS 不支持从开启了加速数据库恢复 (ADR) 的数据库进行复制。 + AWS DMS 不支持在单个事务中捕获数据定义语言 (DDL) 和数据操作语言 (DML) 语句。 + AWS DMS 不支持复制数据层应用程序包 (DACPAC)。 + 当您将更改应用于目标数据库时，涉及主键或唯一索引并更新多个数据行的 UPDATE 语句可能会导致冲突。例如，当目标数据库通过 INSERT 和 DELETE 语句而不是单个 UPDATE 语句应用更新时，可能会发生这种情况。在批量优化应用模式中，该表可能会被忽略。在事务应用模式下，UPDATE 操作可能会导致违反约束。要避免出现此问题，请重新加载相关表。或者，在 Apply Exceptions 控制表（`dmslogs.awsdms_apply_exceptions`）中找到有问题的记录，然后在目标数据库中手动对其进行编辑。有关更多信息，请参阅 [更改处理优化设置](CHAP_Tasks.CustomizingTasks.TaskSettings.ChangeProcessingTuning.md)。 + AWS DMS 不支持表和架构的复制，其中名称包含以下集合中的特殊字符。 `\\ -- \n \" \b \r ' \t ;` + 不支持数据屏蔽。 AWS DMS 在不进行屏蔽的情况下迁移被屏蔽的数据。 + AWS DMS 最多复制 32,767 个带主键的表，每个表最多可复制 1,000 个列。这是因为 AWS DMS 会为每个复制的表创建一个 SQL Server 复制文章，而 SQL Server 复制文章有这些限制。 + 使用更改数据捕获（CDC）时，必须将构成唯一索引的所有列定义为 `NOT NULL`。如果不满足此要求，将导致出现 SQL Server 系统错误 22838。 + 如果 SQL Server 将事件从活动事务日志归档到备份日志，或者将其从活动事务日志中截断，则可能丢失事件。 访问备份事务日志时适用以下限制： + 不支持加密的备份。 + 不支持存储在 URL 或 Windows Azure 上的备份。 + AWS DMS doe snot 支持在文件级别直接处理备用共享文件夹中的事务日志备份。 + 对于除适用于微软 SQL Server 的 Amazon RDS 以外的 Cloud SQL Server 源，仅 AWS DMS 支持使用活动事务日志进行持续复制 (CDC)。您不能将备份日志用于 CDC。如果 SQL Server 将事件从活动事务日志归档到备份日志，或者在 DMS 读取之前将事件从活动事务日志中截断，则可能丢失事件。 + 对于适用于 Microsoft SQL Server 的 Amazon RDS 源， AWS DMS 3.5.2 及更低版本仅支持使用活动事务日志进行持续复制 (CDC)，因为 DMS 无法通过 CDC 访问备份日志。如果 RDS for SQL Server 将事件从活动事务日志归档到备份日志，或者在 DMS 读取之前将事件从活动事务日志中截断，则可能丢失事件。此限制不适用于 3.5.3 及更高 AWS DMS 版本。 + AWS DMS 不支持将适用于 SQL Server 的 Amazon RDS 代理的 CDC 作为来源。 + 如果 SQL Server 源在完全加载任务期间不可用，则即使数据迁移仍未完成， AWS DMS 也可能会在多次尝试重新连接后将任务标记为已完成。在这种情况下，目标表仅包含连接中断之前迁移的记录，这可能会在源系统和目标系统之间造成数据不一致。为确保数据的完整性，您必须完全重新启动满载任务，或者重新加载受连接中断影响的特定表。 ## SQL Server 任务权限 **Topics** + [仅完全加载任务的权限](#CHAP_Source.SQLServer.Permissions.FullLoad) + [持续复制任务权限](#CHAP_Source.SQLServer.Permissions.Ongoing) ### 仅完全加载任务的权限 要执行仅完全加载的任务，需要以下权限。请注意， AWS DMS 不会创建 `dms_user` 登录角色。有关为 SQL Server 创建登录的信息，请参阅 *Microsoft 文档*中的[创建数据库用户](https://learn.microsoft.com/en-us/sql/relational-databases/security/authentication-access/create-a-database-user?view=sql-server-ver16)主题。 ``` USE db_name; CREATE USER dms_user FOR LOGIN dms_user; ALTER ROLE [db_datareader] ADD MEMBER dms_user; GRANT VIEW DATABASE STATE to dms_user; GRANT VIEW DEFINITION to dms_user; USE master; GRANT VIEW SERVER STATE TO dms_user; ``` ### 持续复制任务权限 无论是否使用 `sysadmin` 角色，都可以使用 DMS 将自管理 SQL Server 实例配置为持续复制。对于无法授予 `sysadmin` 角色的 SQL Server 实例，请确保 DMS 用户具有如下所述的权限。 **从自管理 SQL Server 数据库进行持续复制所需的设置权限** 1. 使用 SQL Server Management Studio（SSMS）或如前面的[仅完全加载任务的权限](#CHAP_Source.SQLServer.Permissions.FullLoad)中所述，创建采用密码身份验证的新 SQL Server 账户，例如 `self_managed_user`。 1. 运行以下 `GRANT` 命令： ``` GRANT VIEW SERVER STATE TO self_managed_user; USE msdb; GRANT SELECT ON msdb.dbo.backupset TO self_managed_user; GRANT SELECT ON msdb.dbo.backupmediafamily TO self_managed_user; GRANT SELECT ON msdb.dbo.backupfile TO self_managed_user; USE db_name; CREATE USER self_managed_user FOR LOGIN self_managed_user; ALTER ROLE [db_owner] ADD MEMBER self_managed_user; GRANT VIEW DEFINITION to self_managed_user; ``` 1. 除上述权限外，用户还需要以下权限之一： + 用户必须是 `sysadmin` 固定服务器角色的成员 + 配置和权限如[在可用性组环境中的 SQL Server 上设置持续复制：无 sysadmin 角色](CHAP_Source.SQLServer.CDC.md#CHAP_SupportScripts.SQLServer.ag)或[在独立 SQL Server 上设置持续复制：不使用 sysadmin 角色](CHAP_Source.SQLServer.CDC.md#CHAP_SupportScripts.SQLServer.standalone)中所述，具体取决于您的源配置。 #### 从云 SQL Server 数据库进行持续复制所需的设置权限 云托管的 SQL Server 实例是在 Amazon RDS for Microsoft SQL Server、Azure SQL 托管实例或 DMS 支持的任何其他托管云 SQL Server 实例上运行的实例。 使用 SQL Server Management Studio（SSMS）或如前面的[仅完全加载任务的权限](#CHAP_Source.SQLServer.Permissions.FullLoad)中所述，创建采用密码身份验证的新 SQL Server 账户，例如 `rds_user`。 运行以下授权命令。 ``` GRANT VIEW SERVER STATE TO rds_user; ``` 对于 Amazon RDS for Microsoft SQL Server 源，DMS 版本 3.5.3 及更高版本支持从事务日志备份中读取。为确保 DMS 能够访问日志备份，除上述权限外，还要授予 `master` 用户权限或 RDS SQL Server 源上的以下权限： ``` USE msdb; GRANT EXEC ON msdb.dbo.rds_dms_tlog_download TO rds_user; GRANT EXEC ON msdb.dbo.rds_dms_tlog_read TO rds_user; GRANT EXEC ON msdb.dbo.rds_dms_tlog_list_current_lsn TO rds_user; GRANT EXEC ON msdb.dbo.rds_task_status TO rds_user; USE db_name; CREATE USER rds_user FOR LOGIN rds_user; ALTER ROLE [db_owner] ADD MEMBER rds_user; GRANT VIEW DEFINITION to rds_user; ``` 对于 Amazon Azure SQL 托管实例，请授予以下权限： ``` GRANT SELECT ON msdb.dbo.backupset TO rds_user; GRANT SELECT ON msdb.dbo.backupmediafamily TO rds_user; GRANT SELECT ON msdb.dbo.backupfile TO rds_user; ``` ## 在 SQL Server 源中使用持续复制（CDC）的先决条件 您可以针对本地或 Amazon EC2 上的自管理 SQL Server 数据库、诸如 Amazon RDS 之类的云数据库或者 Microsoft Azure SQL 托管实例使用持续复制（更改数据捕获（CDC））。 尤其在对作为 AWS DMS源的 SQL Server 数据库使用持续复制时，存在以下要求： + 必须配置 SQL Server 进行完整备份，并且您必须在开始复制数据之前先进行一次备份。 + 恢复模式必须设置为 **Bulk logged** 或 **Full**。 + 不支持 SQL Server 备份到多个磁盘。如果将备份定义为将数据库备份写入不同磁盘上的多个文件，则 AWS DMS 无法读取数据， AWS DMS 任务将失败。 + 对于自管理 SQL Server 源，在您删除任务时，DMS CDC 任务中使用的源数据库的 SQL Server Replication Publisher 定义不会被删除。SQL Server 系统管理员必须从 SQL Server 删除自管理源的这些定义。 + 在 CDC 期间， AWS DMS 需要查找 SQL Server 事务日志备份才能读取更改。 AWS DMS 不支持使用*非*本机格式的第三方备份软件创建的 SQL Server 事务日志备份。要支持*采用*本机格式并且使用第三方备份软件创建的事务日志备份，请将 `use3rdPartyBackupDevice=Y` 连接属性添加到源端点。 + 对于自管理 SQL Server 源，请注意，在新创建的表发布前，SQL Server 不会捕获对它们的更改。将表添加到 SQL Server 源时，会 AWS DMS 管理发布的创建。但是，该过程可能需要几分钟时间。不会将在该延迟期间对新创建的表执行的操作捕获或复制到目标中。 + AWS DMS 更改数据捕获需要在 SQL Server 中开启完整的事务日志记录。要在 SQL Server 中启用完整事务日志记录，请启用 MS-REPLICATION 或 CHANGE DATA CAPTURE（CDC）。 + 在 MS CDC 捕获作业处理这些更改之前，SQL Server *tlog* 条目不会被标记为可重复使用。 + 内存优化表上不支持 CDC 操作。该限制适用于 SQL Server 2014（在此版本中首次引入该功能）及更高版本。 + AWS DMS 默认情况下，更改数据捕获需要将 Amazon EC2 或 On-Prem SQL 服务器上的分布数据库作为源。因此，请确保在为带有主键的表配置 MS 复制时已激活分发服务器。 ## 支持的 SQL Server 压缩方法 请注意以下有关 AWS DMS支持的 SQL Server 压缩方法的内容： + AWS DMS 在 SQL Server 版本 2008 及更高版本中支持 Row/Page 压缩。 + AWS DMS 不支持 Vardecimal 存储格式。 + AWS DMS 不支持稀疏列和列结构压缩。 ## 使用自行管理的 SQL Server AlwaysOn 可用性组 SQL Server Always On 可用性组配有高可用性和灾难恢复解决方案，提供数据库镜像的企业级替代功能。 在中 AWS DMS，您可以从单个主可用性组或辅助可用性组副本迁移更改。 ### 使用主可用性组副本 **要在中使用主可用性组作为源 AWS DMS，请执行以下操作：** 1. 为可用性副本中的所有 SQL Server 实例启用分发选项。有关更多信息，请参阅 [在自管理 SQL Server 上设置持续复制](CHAP_Source.SQLServer.CDC.md#CHAP_Source.SQLServer.CDC.MSCDC)。 1. 在 AWS DMS 控制台中，打开 SQL Server 源数据库设置。对于**服务器名称**，请指定为可用性组侦听器配置的域名服务（DNS）名称或 IP 地址。 首次启动 AWS DMS 任务时，可能需要比平时更长的时间才能启动。这种缓慢是因为可用性组服务器正在复制表项目的创建。 ### 使用辅助可用性组副本 **要在中使用辅助可用性组作为源 AWS DMS，请执行以下操作：** 1. 使用与 AWS DMS 源端点用户相同的凭据来连接各个副本。 1. 确保您的 AWS DMS 复制实例可以解析所有现有副本的 DNS 名称并连接到它们。您可以使用以下 SQL 查询来获取所有副本的 DNS 名称。 ``` select ar.replica_server_name, ar.endpoint_url from sys.availability_replicas ar JOIN sys.availability_databases_cluster adc ON adc.group_id = ar.group_id AND adc.database_name = ''; ``` 1. 创建源端点时，请为端点的**服务器名称**或端点密钥的**服务器地址**指定可用性组侦听器的 DNS 名称。有关可用性组侦听器的更多信息，请参阅 SQL Server 文档中的[可用性组侦听器是什么？](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/availability-group-listener-overview?view=sql-server-ver15)。 您可以使用公有 DNS 服务器或本地 DNS 服务器来解析可用性组侦听器、主副本和辅助副本。要使用本地 DNS 服务器，请配置 Amazon Route 53 Resolver。有关更多信息，请参阅 [使用您自己的本地名称服务器](CHAP_BestPractices.md#CHAP_BestPractices.Rte53DNSResolver)。 1. 请将以下额外连接属性添加到您的源端点。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.SQLServer.html) 1. 在您可用性组的所有副本上启用分发选项。将所有节点添加到分发服务器列表中。有关更多信息，请参阅 [设置分发](CHAP_Source.SQLServer.CDC.md#CHAP_Source.SQLServer.CDC.MSCDC.Setup)。 1. 对主读写副本运行以下查询以启用数据库的发布。您只对数据库运行一次此查询。 ``` sp_replicationdboption @dbname = N'', @optname = N'publish', @value = N'true'; ``` #### 限制 以下是使用辅助可用性组副本的限制： + AWS DMS 使用只读可用性组副本作为源时，不支持 Safeguard。有关更多信息，请参阅 [使用 SQL Server 作为源时的端点设置 AWS DMS](#CHAP_Source.SQLServer.ConnectionAttrib)。 + AWS DMS 使用只读可用性组副本作为源时，不支持`setUpMsCdcForTables`额外的连接属性。有关更多信息，请参阅 [使用 SQL Server 作为源时的端点设置 AWS DMS](#CHAP_Source.SQLServer.ConnectionAttrib)。 + AWS DMS 从版本 3.4.7 开始，可以使用自我管理的辅助可用性组副本作为源数据库，用于持续复制（更改数据捕获或 CDC）。不支持云 SQL Server 多可用区只读副本。如果您使用早期版本的 AWS DMS，请确保使用主可用性组副本作为 CDC 的源数据库。 #### 失效转移到其他节点 如果您将终端节点的`ApplicationIntent`额外连接属性设置为`ReadOnly`，则您的 AWS DMS 任务将连接到只读路由优先级最高的只读节点。当优先级最高的只读节点不可用时，它会失效转移到可用性组中的其他只读节点。如果未设置`ApplicationIntent`，则您的 AWS DMS 任务将仅连接到可用性组中的主（读/写）节点。 ## 使用 SQL Server 作为源时的端点设置 AWS DMS 您可以使用端点设置来配置 SQL Server 源数据库，这与使用额外连接属性类似。您可以在使用 AWS DMS 控制台创建源端点时指定设置，或者使用中带有 `--microsoft-sql-server-settings '{"EndpointSetting": "value", ...}'` JSON 语法的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)命令来指定设置。 下表显示了将 SQL Server 作为源时您可以使用的端点设置。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.SQLServer.html) ## SQL Server 的源数据类型 使用 SQL Server 作为源的数据迁移 AWS DMS 支持大多数 SQL Server 数据类型。下表显示了使用时支持的 SQL Server 源数据类型 AWS DMS 以及 AWS DMS 数据类型的默认映射。 有关如何查看目标中映射的数据类型的信息，请参阅有关所使用的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | SQL Server 数据类型 | AWS DMS 数据类型 | | --- | --- | | BIGINT | INT8 | | BIT | BOOLEAN | | DECIMAL | NUMERIC | | INT | INT4 | | MONEY | NUMERIC | | NUMERIC (p,s) | NUMERIC | | SMALLINT | INT2 | | SMALLMONEY | NUMERIC | | TINYINT | UINT1 | | REAL | REAL4 | | FLOAT | REAL8 | | DATETIME | DATETIME | | DATETIME2 （SQL Server 2008 及更高版本） | DATETIME | | SMALLDATETIME | DATETIME | | DATE | DATE | | TIME | TIME | | DATETIMEOFFSET | WSTRING | | CHAR | string | | VARCHAR | string | | VARCHAR (max) | CLOB TEXT 要将此数据类型与一起使用 AWS DMS，必须为特定任务启用 CLOB 数据类型。 对于 SQL Server 表， AWS DMS 即使对于不更改 SQL Server 中 LOB 列值的 UPDATE 语句，也会更新目标中的 LOB 列。 在 CDC 期间，仅在包含主键的表中 AWS DMS 支持 CLOB 数据类型。 | | NCHAR | WSTRING | | NVARCHAR (length) | WSTRING | | NVARCHAR (max) | NCLOB NTEXT 要将此数据类型与一起使用 AWS DMS，必须 SupportLobs 为特定任务启用使用。有关启用 Lob 支持的更多信息，请参阅[在任务中为源数据库设置 LOB 支持 AWS DMS](CHAP_Tasks.LOBSupport.md)。 对于 SQL Server 表， AWS DMS 即使对于不更改 SQL Server 中 LOB 列值的 UPDATE 语句，也会更新目标中的 LOB 列。 在 CDC 期间，仅在包含主键的表中 AWS DMS 支持 CLOB 数据类型。 | | BINARY | BYTES | | VARBINARY | BYTES | | VARBINARY (max) | BLOB IMAGE 对于 SQL Server 表， AWS DMS 即使对于不更改 SQL Server 中 LOB 列值的 UPDATE 语句，也会更新目标中的 LOB 列。 要将此数据类型与一起使用 AWS DMS，必须允许将 BLOB 数据类型用于特定任务。 AWS DMS 仅在包含主键的表中支持 BLOB 数据类型。 | | TIMESTAMP | BYTES | | UNIQUEIDENTIFIER | string | | HIERARCHYID | 在复制到 SQL Server 目标终端节点时，使用 HIERARCHYID。 在复制到所有其他目标终端节点时，使用 WSTRING (250)。 | | XML | NCLOB 对于 SQL Server 表， AWS DMS 即使对于不更改 SQL Server 中 LOB 列值的 UPDATE 语句，也会更新目标中的 LOB 列。 要将此数据类型与一起使用 AWS DMS，必须允许将 NCLOB 数据类型用于特定任务。 在 CDC 期间，仅在包含主键的表中 AWS DMS 支持 NCLOB 数据类型。 | | GEOMETRY | 在复制到支持此数据类型的目标终端节点时，使用 GEOMETRY。 在复制到不支持此数据类型的目标终端节点时，使用 CLOB。 | | GEOGRAPHY | 在复制到支持此数据类型的目标终端节点时，使用 GEOGRAPHY。 在复制到不支持此数据类型的目标终端节点时，使用 CLOB。 | AWS DMS 不支持包含以下数据类型的字段的表。 + CURSOR + SQL\$1VARIANT + TABLE **注意** 根据用户定义的数据类型的基类型来支持这些类型。例如，基于 DATETIME 的用户定义的数据类型将作为 DATETIME 数据类型进行处理。 # 捕获数据更改，以便从 SQL Server 进行持续复制 本主题介绍如何在 SQL Server 源上设置 CDC 复制。 **Topics** + [捕获本地或 Amazon EC2 上的自管理 SQL Server 的数据更改](#CHAP_Source.SQLServer.CDC.Selfmanaged) + [在云 SQL Server 数据库实例上设置持续复制](#CHAP_Source.SQLServer.Configuration) ## 捕获本地或 Amazon EC2 上的自管理 SQL Server 的数据更改 要从源 Microsoft SQL Server 数据库中捕获更改，请确保该数据库已配置为进行完整备份。将数据库配置为完全恢复模式或批量日志记录模式。 对于自行管理的 SQL Server 源，请 AWS DMS 使用以下内容： **MS-Replication** 用于捕获带主键的表的更改。您可以通过向源 SQL Server 实例上的 AWS DMS 端点用户授予系统管理员权限来自动进行配置。或者，您可以按照本节中的步骤准备源代码并使用对端点不具有 sysadmin 权限的 AWS DMS 用户。 **MS-CDC** 用于捕获不带主键的表的更改。MS-CDC 必须在数据库级别上启用，并且为各个表分别启用。 设置 SQL Server 数据库进行持续复制（CDC）时，可以执行下列操作之一： + 使用 sysadmin 角色设置持续复制。 + 将持续复制设置为不使用 sysadmin 角色。 **注意** 您可以使用以下脚本查找所有没有主键或唯一键的表： ``` USE [DBname] SELECT SCHEMA_NAME(schema_id) AS schema_name, name AS table_name FROM sys.tables WHERE OBJECTPROPERTY(object_id, 'TableHasPrimaryKey') = 0 AND OBJECTPROPERTY(object_id, 'TableHasUniqueCnst') = 0 ORDER BY schema_name, table_name; ``` ### 在自管理 SQL Server 上设置持续复制 本部分包含有关使用或不使用 sysadmin 角色在自管理 SQL Server 上设置持续复制的信息。 **Topics** + [在自管理 SQL Server 上设置持续复制：使用 sysadmin 角色](#CHAP_Source.SQLServer.CDC.MSCDC.Sysadmin) + [在独立 SQL Server 上设置持续复制：不使用 sysadmin 角色](#CHAP_SupportScripts.SQLServer.standalone) + [在可用性组环境中的 SQL Server 上设置持续复制：无 sysadmin 角色](#CHAP_SupportScripts.SQLServer.ag) #### 在自管理 SQL Server 上设置持续复制：使用 sysadmin 角色 AWS DMS SQL Server 的持续复制对带主键的表使用本机 SQL Server 复制，对没有主键的表使用更改数据捕获 (CDC)。 在设置持续复制之前，请参阅[在 SQL Server 源中使用持续复制（CDC）的先决条件](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Prerequisites)。 对于带有主键的表，通常 AWS DMS 可以在源上配置所需的工件。但对于自管理 SQL Server 源数据库实例，必须先手动配置 SQL Server 分发。执行此操作后，具有 sysadmin 权限的 AWS DMS 源用户可以自动为具有主键的表创建发布。 要检查是否已配置分发，请运行以下命令。 ``` sp_get_distributor ``` 如果列分发的结果是 `NULL`，则未配置分发。请使用以下过程设置分发。 **设置分发** 1. 使用 SQL Server Management Studio（SSMS）工具连接到 SQL Server 源数据库。 1. 打开**复制**文件夹的上下文（右键单击）菜单，然后选择**配置分发**。此时将显示“配置分发向导”。 1. 按照向导输入默认值并创建分发。 **设置 CDC** AWS DMS 如果您不使用只读副本，3.4.7 及更高版本可以自动为您的数据库和所有表设置 MS CDC。要使用此功能，请将 `SetUpMsCdcForTables` ECA 设置为 true。有关的信息 ECAs，请参见[端点设置](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.ConnectionAttrib)。 对于 3.4.7 AWS DMS 之前的版本或作为源的只读副本，请执行以下步骤： 1. 对于无主键的表，请为数据库设置 MS-CDC。要执行此操作，请使用分配了 sysadmin 角色的账户，然后运行以下命令。 ``` use [DBname] EXEC sys.sp_cdc_enable_db ``` 1. 接下来，为每个源表设置 MS-CDC。对于具有唯一键但没有主键的每个表，运行以下查询来设置 MS-CDC。 ``` exec sys.sp_cdc_enable_table @source_schema = N'schema_name', @source_name = N'table_name', @index_name = N'unique_index_name', @role_name = NULL, @supports_net_changes = 1 GO ``` 1. 对于没有主键或唯一键的每个表，运行以下查询来设置 MS-CDC。 ``` exec sys.sp_cdc_enable_table @source_schema = N'schema_name', @source_name = N'table_name', @role_name = NULL GO ``` 有关为特定表设置 MS-CDC 的更多信息，请参阅 [ SQL Server 文档](https://msdn.microsoft.com/en-us/library/cc627369.aspx)。 #### 在独立 SQL Server 上设置持续复制：不使用 sysadmin 角色 本节介绍如何针对 SQL Server 数据库源设置不需要用户账户具有 sysadmin 权限的持续复制。 **注意** 运行本节中的步骤后，非 sysadmin DMS 用户将有权执行以下操作： 从联机事务日志文件中读取更改 通过访问磁盘从事务日志备份文件中读取更改 添加或更改 DMS 使用的发布内容 向发布内容中添加文章 1. 按照[捕获数据更改，以便从 SQL Server 进行持续复制](#CHAP_Source.SQLServer.CDC)中所述设置用于复制的 Microsoft SQL Server。 1. 在源数据库上启用 MS-REPLICATION。这可以手动完成，也可以通过 sysadmin 用户身份运行一次任务来完成。 1. 使用以下脚本，在源数据库上创建 `awsdms` 架构： ``` use master go create schema awsdms go -- Create the table valued function [awsdms].[split_partition_list] on the Master database, as follows: USE [master] GO set ansi_nulls on go set quoted_identifier on go if (object_id('[awsdms].[split_partition_list]','TF')) is not null drop function [awsdms].[split_partition_list]; go create function [awsdms].[split_partition_list] ( @plist varchar(8000), --A delimited list of partitions @dlm nvarchar(1) --Delimiting character ) returns @partitionsTable table --Table holding the BIGINT values of the string fragments ( pid bigint primary key ) as begin declare @partition_id bigint; declare @dlm_pos integer; declare @dlm_len integer; set @dlm_len = len(@dlm); while (charindex(@dlm,@plist)>0) begin set @dlm_pos = charindex(@dlm,@plist); set @partition_id = cast( ltrim(rtrim(substring(@plist,1,@dlm_pos-1))) as bigint); insert into @partitionsTable (pid) values (@partition_id) set @plist = substring(@plist,@dlm_pos+@dlm_len,len(@plist)); end set @partition_id = cast (ltrim(rtrim(@plist)) as bigint); insert into @partitionsTable (pid) values ( @partition_id ); return end GO ``` 1. 使用以下脚本，在 Master 数据库上创建 `[awsdms].[rtm_dump_dblog]` 过程： ``` use [MASTER] go if (object_id('[awsdms].[rtm_dump_dblog]','P')) is not null drop procedure [awsdms].[rtm_dump_dblog]; go set ansi_nulls on go set quoted_identifier on GO CREATE procedure [awsdms].[rtm_dump_dblog] ( @start_lsn varchar(32), @seqno integer, @filename varchar(260), @partition_list varchar(8000), -- A comma delimited list: P1,P2,... Pn @programmed_filtering integer, @minPartition bigint, @maxPartition bigint ) as begin declare @start_lsn_cmp varchar(32); -- Stands against the GT comparator SET NOCOUNT ON -- – Disable "rows affected display" set @start_lsn_cmp = @start_lsn; if (@start_lsn_cmp) is null set @start_lsn_cmp = '00000000:00000000:0000'; if (@partition_list is null) begin RAISERROR ('Null partition list waspassed',16,1); return end if (@start_lsn) is not null set @start_lsn = '0x'+@start_lsn; if (@programmed_filtering=0) SELECT [Current LSN], [operation], [Context], [Transaction ID], [Transaction Name], [Begin Time], [End Time], [Flag Bits], [PartitionID], [Page ID], [Slot ID], [RowLog Contents 0], [Log Record], [RowLog Contents 1] FROM fn_dump_dblog ( @start_lsn, NULL, N'DISK', @seqno, @filename, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default) where [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS and ( ( [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') ) or ( [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW') and ( ( [context] in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX' and (datalength([RowLog Contents 0]) in (0,1)))) and [PartitionID] in ( select * from master.awsdms.split_partition_list (@partition_list,',')) ) or ([operation] = 'LOP_HOBT_DDL') ) else SELECT [Current LSN], [operation], [Context], [Transaction ID], [Transaction Name], [Begin Time], [End Time], [Flag Bits], [PartitionID], [Page ID], [Slot ID], [RowLog Contents 0], [Log Record], [RowLog Contents 1] -- After Image FROM fn_dump_dblog ( @start_lsn, NULL, N'DISK', @seqno, @filename, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default) where [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS and ( ( [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') ) or ( [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW') and ( ( [context] in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX' and (datalength([RowLog Contents 0]) in (0,1)))) and ([PartitionID] is not null) and ([PartitionID] >= @minPartition and [PartitionID]<=@maxPartition) ) or ([operation] = 'LOP_HOBT_DDL') ) SET NOCOUNT OFF -- Re-enable "rows affected display" end GO ``` 1. 使用以下脚本，在 Master 数据库上创建证书： ``` Use [master] Go CREATE CERTIFICATE [awsdms_rtm_dump_dblog_cert] ENCRYPTION BY PASSWORD = N'@5trongpassword' WITH SUBJECT = N'Certificate for FN_DUMP_DBLOG Permissions'; ``` 1. 使用以下脚本，从证书创建登录名： ``` Use [master] Go CREATE LOGIN awsdms_rtm_dump_dblog_login FROM CERTIFICATE [awsdms_rtm_dump_dblog_cert]; ``` 1. 使用以下脚本，将登录名添加到 sysadmin 服务器角色： ``` ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_dump_dblog_login]; ``` 1. 通过以下脚本，使用证书将签名添加到 [master].[awsdms].[rtm\$1dump\$1dblog]。 ``` Use [master] GO ADD SIGNATURE TO [master].[awsdms].[rtm_dump_dblog] BY CERTIFICATE [awsdms_rtm_dump_dblog_cert] WITH PASSWORD = '@5trongpassword'; ``` **注意** 如果重新创建存储过程，您需要再次添加签名。 1. 使用以下脚本在 Master 数据库上创建 [awsdms].[rtm\$1position\$11st\$1timestamp]： ``` use [master] if object_id('[awsdms].[rtm_position_1st_timestamp]','P') is not null DROP PROCEDURE [awsdms].[rtm_position_1st_timestamp]; go create procedure [awsdms].[rtm_position_1st_timestamp] ( @dbname sysname, -- Database name @seqno integer, -- Backup set sequence/position number within file @filename varchar(260), -- The backup filename @1stTimeStamp varchar(40) -- The timestamp to position by ) as begin SET NOCOUNT ON -- Disable "rows affected display" declare @firstMatching table ( cLsn varchar(32), bTim datetime ) declare @sql nvarchar(4000) declare @nl char(2) declare @tb char(2) declare @fnameVar nvarchar(254) = 'NULL' set @nl = char(10); -- New line set @tb = char(9) -- Tab separator if (@filename is not null) set @fnameVar = ''''+@filename +'''' set @sql='use ['+@dbname+'];'+@nl+ 'select top 1 [Current LSN],[Begin Time]'+@nl+ 'FROM fn_dump_dblog (NULL, NULL, NULL, '+ cast(@seqno as varchar(10))+','+ @fnameVar+','+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default)'+@nl+ 'where operation=''LOP_BEGIN_XACT''' +@nl+ 'and [Begin Time]>= cast('+''''+@1stTimeStamp+''''+' as datetime)'+@nl --print @sql delete from @firstMatching insert into @firstMatching exec sp_executesql @sql -- Get them all select top 1 cLsn as [matching LSN],convert(varchar,bTim,121) as [matching Timestamp] from @firstMatching; SET NOCOUNT OFF -- Re-enable "rows affected display" end GO ``` 1. 使用以下脚本，在 Master 数据库上创建证书： ``` Use [master] Go CREATE CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert] ENCRYPTION BY PASSWORD = '@5trongpassword' WITH SUBJECT = N'Certificate for FN_POSITION_1st_TIMESTAMP Permissions'; ``` 1. 使用以下脚本，从证书创建登录名： ``` Use [master] Go CREATE LOGIN awsdms_rtm_position_1st_timestamp_login FROM CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert]; ``` 1. 使用以下脚本，将登录名添加到 sysadmin 角色： ``` ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_position_1st_timestamp_login]; ``` 1. 通过以下脚本，使用证书将签名添加到 [master].[awsdms].[rtm\$1position\$11st\$1timestamp]： ``` Use [master] GO ADD SIGNATURE TO [master].[awsdms].[rtm_position_1st_timestamp] BY CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert] WITH PASSWORD = '@5trongpassword'; ``` 1. 使用以下脚本向 DMS 用户授予对新存储过程的执行访问权限： ``` use master go GRANT execute on [awsdms].[rtm_position_1st_timestamp] to dms_user; ``` 1. 在以下每个数据库中，创建具有以下权限和角色的用户： **注意** 您应该在每个副本上使用相同的 SID 创建 dmsnosysadmin 用户账户。以下 SQL 查询可以帮助验证每个副本上的 dmsnosysadmin 账户 SID 值。有关创建用户的更多信息，请参阅 [Microsoft SQL Server 文档](https://learn.microsoft.com/en-us/sql/)中的 [CREATE USER（Transact-SQL）](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-user-transact-sql)。有关为 Azure SQL 数据库创建 SQL 用户账户的更多信息，请参阅[活动异地复制](https://learn.microsoft.com/en-us/azure/azure-sql/database/active-geo-replication-overview)。 ``` use master go grant select on sys.fn_dblog to [DMS_user] grant view any definition to [DMS_user] grant view server state to [DMS_user]--(should be granted to the login). grant execute on sp_repldone to [DMS_user] grant execute on sp_replincrementlsn to [DMS_user] grant execute on sp_addpublication to [DMS_user] grant execute on sp_addarticle to [DMS_user] grant execute on sp_articlefilter to [DMS_user] grant select on [awsdms].[split_partition_list] to [DMS_user] grant execute on [awsdms].[rtm_dump_dblog] to [DMS_user] ``` ``` use msdb go grant select on msdb.dbo.backupset to self_managed_user grant select on msdb.dbo.backupmediafamily to self_managed_user grant select on msdb.dbo.backupfile to self_managed_user ``` 在源数据库上运行以下脚本： ``` use Source_DB Go EXEC sp_addrolemember N'db_owner', N'DMS_user' ``` 1. 最后，向源 SQL Server 端点添加额外连接属性（ECA）： ``` enableNonSysadminWrapper=true; ``` #### 在可用性组环境中的 SQL Server 上设置持续复制：无 sysadmin 角色 本节介绍如何在不需要用户账户具有 sysadmin 权限的可用性组环境中为 SQL Server 数据库源设置持续复制。 **注意** 运行本节中的步骤后，非 sysadmin DMS 用户将有权执行以下操作： 从联机事务日志文件中读取更改 通过访问磁盘从事务日志备份文件中读取更改 添加或更改 DMS 使用的发布内容 向发布内容中添加文章 **在可用性组环境中设置持续复制而不使用 sysadmin 用户** 1. 按照[捕获数据更改，以便从 SQL Server 进行持续复制](#CHAP_Source.SQLServer.CDC)中所述设置用于复制的 Microsoft SQL Server。 1. 在源数据库上启用 MS-REPLICATION。这可以手动完成，也可以使用 sysadmin 用户身份运行一次任务来完成。 **注意** 您应该将 MS-REPLICATION 分发服务器配置为本地分发服务器，或者配置为允许非 sysadmin 用户通过关联的链接服务器进行访问。 1. 如果启用**在单个任务中独占使用 sp\$1repldone** 端点选项，请停止 MS-REPLICATION 日志读取器作业。 1. 在每个副本上，执行以下步骤： 1. 在 Master 数据库中创建 `[awsdms]`[awsdms] 架构： ``` CREATE SCHEMA [awsdms] ``` 1. 在 Master 数据库中创建 `[awsdms].[split_partition_list]` 表值函数： ``` USE [master] GO SET ansi_nulls on GO SET quoted_identifier on GO IF (object_id('[awsdms].[split_partition_list]','TF')) is not null DROP FUNCTION [awsdms].[split_partition_list]; GO CREATE FUNCTION [awsdms].[split_partition_list] ( @plist varchar(8000), --A delimited list of partitions @dlm nvarchar(1) --Delimiting character ) RETURNS @partitionsTable table --Table holding the BIGINT values of the string fragments ( pid bigint primary key ) AS BEGIN DECLARE @partition_id bigint; DECLARE @dlm_pos integer; DECLARE @dlm_len integer; SET @dlm_len = len(@dlm); WHILE (charindex(@dlm,@plist)>0) BEGIN SET @dlm_pos = charindex(@dlm,@plist); SET @partition_id = cast( ltrim(rtrim(substring(@plist,1,@dlm_pos-1))) as bigint); INSERT into @partitionsTable (pid) values (@partition_id) SET @plist = substring(@plist,@dlm_pos+@dlm_len,len(@plist)); END SET @partition_id = cast (ltrim(rtrim(@plist)) as bigint); INSERT into @partitionsTable (pid) values ( @partition_id ); RETURN END GO ``` 1. 在 Master 数据库中创建 `[awsdms].[rtm_dump_dblog]` 过程： ``` USE [MASTER] GO IF (object_id('[awsdms].[rtm_dump_dblog]','P')) is not null DROP PROCEDURE [awsdms].[rtm_dump_dblog]; GO SET ansi_nulls on GO SET quoted_identifier on GO CREATE PROCEDURE [awsdms].[rtm_dump_dblog] ( @start_lsn varchar(32), @seqno integer, @filename varchar(260), @partition_list varchar(8000), -- A comma delimited list: P1,P2,... Pn @programmed_filtering integer, @minPartition bigint, @maxPartition bigint ) AS BEGIN DECLARE @start_lsn_cmp varchar(32); -- Stands against the GT comparator SET NOCOUNT ON -- Disable "rows affected display" SET @start_lsn_cmp = @start_lsn; IF (@start_lsn_cmp) is null SET @start_lsn_cmp = '00000000:00000000:0000'; IF (@partition_list is null) BEGIN RAISERROR ('Null partition list was passed',16,1); return --set @partition_list = '0,'; -- A dummy which is never matched END IF (@start_lsn) is not null SET @start_lsn = '0x'+@start_lsn; IF (@programmed_filtering=0) SELECT [Current LSN], [operation], [Context], [Transaction ID], [Transaction Name], [Begin Time], [End Time], [Flag Bits], [PartitionID], [Page ID], [Slot ID], [RowLog Contents 0], [Log Record], [RowLog Contents 1] -- After Image FROM fn_dump_dblog ( @start_lsn, NULL, N'DISK', @seqno, @filename, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default) WHERE [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS -- This aims for implementing FN_DBLOG based on GT comparator. AND ( ( [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') ) OR ( [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW') AND ( ( [context] in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX') ) AND [PartitionID] in ( select * from master.awsdms.split_partition_list (@partition_list,',')) ) OR ([operation] = 'LOP_HOBT_DDL') ) ELSE SELECT [Current LSN], [operation], [Context], [Transaction ID], [Transaction Name], [Begin Time], [End Time], [Flag Bits], [PartitionID], [Page ID], [Slot ID], [RowLog Contents 0], [Log Record], [RowLog Contents 1] -- After Image FROM fn_dump_dblog ( @start_lsn, NULL, N'DISK', @seqno, @filename, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default) WHERE [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS -- This aims for implementing FN_DBLOG based on GT comparator. AND ( ( [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') ) OR ( [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW') AND ( ( [context] in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX') ) AND ([PartitionID] is not null) and ([PartitionID] >= @minPartition and [PartitionID]<=@maxPartition) ) OR ([operation] = 'LOP_HOBT_DDL') ) SET NOCOUNT OFF -- Re-enable "rows affected display" END GO ``` 1. 在 Master 数据库上创建证书： ``` USE [master] GO CREATE CERTIFICATE [awsdms_rtm_dump_dblog_cert] ENCRYPTION BY PASSWORD = N'@hardpassword1' WITH SUBJECT = N'Certificate for FN_DUMP_DBLOG Permissions' ``` 1. 从证书创建登录名： ``` USE [master] GO CREATE LOGIN awsdms_rtm_dump_dblog_login FROM CERTIFICATE [awsdms_rtm_dump_dblog_cert]; ``` 1. 将登录名添加到 sysadmin 服务器角色： ``` ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_dump_dblog_login]; ``` 1. 使用证书将签名添加到 [master].[awsdms].[rtm\$1dump\$1dblog] 过程： ``` USE [master] GO ADD SIGNATURE TO [master].[awsdms].[rtm_dump_dblog] BY CERTIFICATE [awsdms_rtm_dump_dblog_cert] WITH PASSWORD = '@hardpassword1'; ``` **注意** 如果重新创建存储过程，您需要再次添加签名。 1. 在 Master 数据库中创建 `[awsdms].[rtm_position_1st_timestamp]` 过程： ``` USE [master] IF object_id('[awsdms].[rtm_position_1st_timestamp]','P') is not null DROP PROCEDURE [awsdms].[rtm_position_1st_timestamp]; GO CREATE PROCEDURE [awsdms].[rtm_position_1st_timestamp] ( @dbname sysname, -- Database name @seqno integer, -- Backup set sequence/position number within file @filename varchar(260), -- The backup filename @1stTimeStamp varchar(40) -- The timestamp to position by ) AS BEGIN SET NOCOUNT ON -- Disable "rows affected display" DECLARE @firstMatching table ( cLsn varchar(32), bTim datetime ) DECLARE @sql nvarchar(4000) DECLARE @nl char(2) DECLARE @tb char(2) DECLARE @fnameVar sysname = 'NULL' SET @nl = char(10); -- New line SET @tb = char(9) -- Tab separator IF (@filename is not null) SET @fnameVar = ''''+@filename +'''' SET @filename = ''''+@filename +'''' SET @sql='use ['+@dbname+'];'+@nl+ 'SELECT TOP 1 [Current LSN],[Begin Time]'+@nl+ 'FROM fn_dump_dblog (NULL, NULL, NULL, '+ cast(@seqno as varchar(10))+','+ @filename +','+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default,'+@nl+ @tb+'default, default, default, default, default, default, default)'+@nl+ 'WHERE operation=''LOP_BEGIN_XACT''' +@nl+ 'AND [Begin Time]>= cast('+''''+@1stTimeStamp+''''+' as datetime)'+@nl --print @sql DELETE FROM @firstMatching INSERT INTO @firstMatching exec sp_executesql @sql -- Get them all SELECT TOP 1 cLsn as [matching LSN],convert(varchar,bTim,121) AS[matching Timestamp] FROM @firstMatching; SET NOCOUNT OFF -- Re-enable "rows affected display" END GO ``` 1. 在 Master 数据库上创建证书： ``` USE [master] GO CREATE CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert] ENCRYPTION BY PASSWORD = N'@hardpassword1' WITH SUBJECT = N'Certificate for FN_POSITION_1st_TIMESTAMP Permissions'; ``` 1. 从证书创建登录名： ``` USE [master] GO CREATE LOGIN awsdms_rtm_position_1st_timestamp_login FROM CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert]; ``` 1. 将登录名添加到 sysadmin 服务器角色： ``` ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_position_1st_timestamp_login]; ``` 1. 使用证书将签名添加到 `[master].[awsdms].[rtm_position_1st_timestamp]` 过程： ``` USE [master] GO ADD SIGNATURE TO [master].[awsdms].[rtm_position_1st_timestamp] BY CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert] WITH PASSWORD = '@hardpassword1'; ``` **注意** 如果重新创建存储过程，您需要再次添加签名。 1. 在以下每个数据库 permissions/roles 中创建具有以下内容的用户： **注意** 您应该在每个副本上使用相同的 SID 创建 dmsnosysadmin 用户账户。以下 SQL 查询可以帮助验证每个副本上的 dmsnosysadmin 账户 SID 值。有关创建用户的更多信息，请参阅 [Microsoft SQL Server 文档](https://learn.microsoft.com/en-us/sql/)中的 [CREATE USER（Transact-SQL）](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-user-transact-sql)。有关为 Azure SQL 数据库创建 SQL 用户账户的更多信息，请参阅[活动异地复制](https://learn.microsoft.com/en-us/azure/azure-sql/database/active-geo-replication-overview)。 ``` SELECT @@servername servername, name, sid, create_date, modify_date FROM sys.server_principals WHERE name = 'dmsnosysadmin'; ``` 1. 在每个副本上授予对 Master 数据库的权限： ``` USE master GO GRANT select on sys.fn_dblog to dmsnosysadmin; GRANT view any definition to dmsnosysadmin; GRANT view server state to dmsnosysadmin -- (should be granted to the login). GRANT execute on sp_repldone to dmsnosysadmin; GRANT execute on sp_replincrementlsn to dmsnosysadmin; GRANT execute on sp_addpublication to dmsnosysadmin; GRANT execute on sp_addarticle to dmsnosysadmin; GRANT execute on sp_articlefilter to dmsnosysadmin; GRANT select on [awsdms].[split_partition_list] to dmsnosysadmin; GRANT execute on [awsdms].[rtm_dump_dblog] to dmsnosysadmin; GRANT execute on [awsdms].[rtm_position_1st_timestamp] to dmsnosysadmin; ``` 1. 在每个副本上授予对 MSDB 数据库的权限： ``` USE msdb GO GRANT select on msdb.dbo.backupset TO self_managed_user GRANT select on msdb.dbo.backupmediafamily TO self_managed_user GRANT select on msdb.dbo.backupfile TO self_managed_user ``` 1. 在源数据库上将 `db_owner` 角色添加到 `dmsnosysadmin`。由于数据库已同步，您只能在主副本上添加角色。 ``` use GO EXEC sp_addrolemember N'db_owner', N'dmsnosysadmin' ``` ## 在云 SQL Server 数据库实例上设置持续复制 此部分介绍如何在云托管 SQL Server 数据库实例上设置 CDC。云托管的 SQL 服务器实例是在 Amazon RDS for SQL Server、Azure SQL 托管实例或任何其他托管云 SQL Server 实例上运行的实例。有关每种数据库类型的持续复制限制的信息，请参阅[使用 SQL Server 作为源代码的限制 AWS DMS](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Limitations)。 在设置持续复制之前，请参阅[在 SQL Server 源中使用持续复制（CDC）的先决条件](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Prerequisites)。 不同于自管理 Microsoft SQL Server 源，Amazon RDS for SQL Server 不支持 MS-Replication。因此， AWS DMS 需要对带或不带主键的表使用 MS-CDC。 Amazon RDS 不授予系统管理员设置用于源 SQL Server 实例中持续更改的复制项目的权限。 AWS DMS 请确保在以下过程中使用主用户权限为 Amazon RDS 实例启用 MS-CDC。 **在云 SQL Server 数据库实例上启用 MS-CDC** 1. 在数据库级别运行以下查询之一。 对于 RDS for SQL Server 数据库实例，请使用此查询。 ``` exec msdb.dbo.rds_cdc_enable_db 'DB_name' ``` 对于 Azure SQL 托管数据库实例，请使用此查询。 ``` USE DB_name GO EXEC sys.sp_cdc_enable_db GO ``` 1. 对于带主键的每个表，运行以下查询来启用 MS-CDC。 ``` exec sys.sp_cdc_enable_table @source_schema = N'schema_name', @source_name = N'table_name', @role_name = NULL, @supports_net_changes = 1 GO ``` 对于有唯一键但没有主键的每个表，运行以下查询来启用 MS-CDC。 ``` exec sys.sp_cdc_enable_table @source_schema = N'schema_name', @source_name = N'table_name', @index_name = N'unique_index_name', @role_name = NULL, @supports_net_changes = 1 GO ``` 对于既没有主键又没有唯一键的每个表，运行以下查询来启用 MS-CDC。 ``` exec sys.sp_cdc_enable_table @source_schema = N'schema_name', @source_name = N'table_name', @role_name = NULL GO ``` 1. 设置保留期： + 对于使用 DMS 版本 3.5.3 及更高版本进行复制的 RDS for SQL Server 实例，请确保将保留期设置为 5 秒（默认值）。如果要从 DMS 3.5.2 及更低版本升级或迁移到 DMS 3.5.3 及更高版本，当任务在新实例或升级后的实例上运行后，请更改轮询间隔值。以下脚本将保留期设置为 5 秒： ``` use dbname EXEC sys.sp_cdc_change_job @job_type = 'capture' ,@pollinginterval = 5 exec sp_cdc_stop_job 'capture' exec sp_cdc_start_job 'capture' ``` + 参数 `@pollinginterval` 按秒计，建议值设置为 86399。当该参数为 `@pollinginterval = 86399` 时，这意味着事务日志将更改保留 86399 秒（一天）。过程 `exec sp_cdc_start_job 'capture'` 启动这些设置。 **注意** 对于某些 SQL Server 版本，如果 `pollinginterval` 的值设置为超过 3599 秒，该值将重置为默认的五秒。发生这种情况时，T-Log 条目会在读取之前 AWS DMS 被清除。要确定哪些 SQL Server 版本受到此已知问题的影响，请参阅[这篇 Microsoft 知识库文章](https://support.microsoft.com/en-us/topic/kb4459220-fix-incorrect-results-occur-when-you-convert-pollinginterval-parameter-from-seconds-to-hours-in-sys-sp-cdc-scan-in-sql-server-dac8aefe-b60b-7745-f987-582dda2cfa78)。 如果您使用带有多可用区的 Amazon RDS，请确保也设置辅助项，以便在失效转移时具有正确的值。 ``` exec rdsadmin..rds_set_configuration 'cdc_capture_pollinginterval' , <5 or preferred value> ``` **在 AWS DMS 复制任务停止超过一小时时保持保留期** **注意** 使用 DMS 3.5.3 及更高版本复制 RDS for SQL Server 源时无需执行以下步骤。 1. 使用以下命令停止截断事务日志的作业。 ``` exec sp_cdc_stop_job 'capture' ``` 1. 在 AWS DMS 控制台上找到您的任务并继续执行任务。 1. 选择**监控**选项卡，然后勾选 `CDCLatencySource` 指标。 1. 如果 `CDCLatencySource` 指标等于 0（零）并保持不变，请使用以下命令重新启动截断事务日志的作业。 ``` exec sp_cdc_start_job 'capture' ``` 记得启动截断 SQL Server 事务日志的作业。否则，您的 SQL Server 实例上的存储空间可能会被填满。 ### 使用适用于 SQL Server 的 RDS 作为来源时的推荐设置 AWS DMS #### 适用于 AWS DMS 3.5.3 及更高版本 **注意** 对于在 DMS 版本 3.5.3 发布之后创建或修改的端点，默认启用 RDS for SQL Server 日志备份特征的初始版本。要将此特征用于现有端点，请在不进行任何更改的情况下修改端点。 AWS DMS 版本 3.5.3 引入了对从日志备份中读取的支持。DMS 主要依靠从活动事务日志中读取数据来复制事件。如果在 DMS 可以从活动日志中读取事务之前对事务进行了备份，则该任务将按需访问 RDS 备份并从后续备份日志中读取数据，直到赶上活动事务日志的步伐。为确保 DMS 可以访问日志备份，请将 RDS 自动备份保留期设置为至少一天。有关设置自动备份保留期的信息，请参阅《Amazon RDS 用户指南》**中的[备份保留期](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ManagingAutomatedBackups.html#USER_WorkingWithAutomatedBackups.BackupRetention)。 访问日志备份的 DMS 任务会使用 RDS 实例上的存储空间。请注意，该任务仅访问复制所需的日志备份。Amazon RDS 会在几小时内删除这些下载的备份。此删除不会影响保留在 Amazon S3 中的 Amazon RDS 备份，也不会影响 Amazon RDS `RESTORE DATABASE` 功能。如果您打算使用 DMS 进行复制，建议在 RDS for SQL Server 源上分配额外的存储空间。估算所需存储量的一种方法是确定 DMS 将从哪个备份开始或恢复复制，然后使用 RDS `tlog backup` 元数据函数将所有后续备份的文件大小相加。有关 `tlog backup` 函数的更多信息，请参阅《Amazon RDS 用户指南》**中的[列出可用的事务日志备份](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER.SQLServer.AddlFeat.TransactionLogAccess.html#USER.SQLServer.AddlFeat.TransactionLogAccess.Listing)。 或者，您可以根据您的 Amazon RDS 实例的 CloudWatch `FreeStorageSpace`指标选择启用存储自动扩展和/或触发存储扩展。 强烈建议您不要从事务日志备份中太远的位置开始或恢复，因为这可能会导致 SQL Server 实例上的存储空间被填满。在这种情况下，建议启动完全加载。从事务日志备份中复制比从活动事务日志中读取要慢。有关更多信息，请参阅 [针对 RDS for SQL Server 的事务日志备份处理](CHAP_Troubleshooting_Latency_Source_SQLServer.md#CHAP_Troubleshooting_Latency_Source_SQLServer_backup)。 请注意，访问日志备份需要额外的权限。有关更多信息，请参阅[从云 SQL Server 数据库进行持续复制所需的设置权限](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Permissions.Cloud)中的详细说明。确保在任务开始复制之前授予这些权限。 #### 适用于 AWS DMS 3.5.2 及更低版本 当您使用 Amazon RDS for SQL Server 作为源时，MS-CDC 捕获作业依赖于参数 `maxscans` 和 `maxtrans`。这些参数控制 MS-CDC 捕获对事务日志执行的最大扫描次数以及每次扫描处理的事务数。 对于事务数大于 `maxtrans*maxscans` 的数据库，增加其 `polling_interval` 值可能会导致活动事务日志记录的累积。这种累积反过来又会导致事务日志的大小增加。 请注意，这 AWS DMS 并不依赖于 MS-CDC 捕获作业。MS-CDC 捕获作业将事务日志条目标记为已处理。这样可允许事务日志备份作业从事务日志中删除条目。 我们建议您监控事务日志的大小和 MS-CDC 作业是否成功。如果 MS-CDC 作业失败，事务日志可能会过度增长并导致 AWS DMS 复制失败。您可以使用源数据库中的 `sys.dm_cdc_errors` 动态管理视图来监控 MS-CDC 捕获作业错误。您可以使用 `DBCC SQLPERF(LOGSPACE)` 管理命令来监控事务日志的大小。 **解决由 MS-CDC 引起的事务日志增加问题** 1. 检查数据库是否 AWS DMS 正在从中复制，并验证它是否持续增加。`Log Space Used %` ``` DBCC SQLPERF(LOGSPACE) ``` 1. 确定阻碍事务日志备份过程的原因。 ``` Select log_reuse_wait, log_reuse_wait_desc, name from sys.databases where name = db_name(); ``` 如果 `log_reuse_wait_desc` 值等于 `REPLICATION`，则说明日志备份保留是 MS-CDC 中的延迟所导致。 1. 通过增加 `maxtrans` 和 `maxscans` 参数值来增加捕获作业处理的事件数。 ``` EXEC sys.sp_cdc_change_job @job_type = 'capture' ,@maxtrans = 5000, @maxscans = 20 exec sp_cdc_stop_job 'capture' exec sp_cdc_start_job 'capture' ``` 要解决此问题，请将`maxscans`和`maxtrans`的值设置`maxtrans*maxscans`为等于每天为从源数据库 AWS DMS 复制的表生成的事件的平均数。 如果将这些参数设置为高于建议值，则捕获作业会处理事务日志中的所有事件。如果将这些参数设置为低于建议值，则 MS-CDC 延迟会增加，事务日志也会增加。 为 `maxscans` 和 `maxtrans` 确定合适的值可能很困难，因为工作负载的变化会产生不同数量的事件。在这种情况下，建议您对 MS-CDC 延迟设置监控。有关更多信息，请参阅 SQL Server 文档中的[监控流程](https://docs.microsoft.com/en-us/sql/relational-databases/track-changes/administer-and-monitor-change-data-capture-sql-server?view=sql-server-ver15#Monitor)。然后根据监控结果动态配置 `maxtrans` 和 `maxscans`。 如果 AWS DMS 任务找不到恢复或继续任务所需的日志序列号 (LSNs)，则该任务可能会失败并需要完全重新加载。 **注意** 使用 AWS DMS 从 RDS for SQL Server 源复制数据时，在 Amazon RDS 实例的停止启动事件之后尝试恢复复制时，您可能会遇到错误。这是由于 SQL Server Agent 进程在停止启动事件后重新启动时，会重新启动捕获作业进程。这绕过了 MS-CDC 轮询间隔。 因此，在事务量低于 MS-CDC 捕获作业处理的数据库上，这可能会导致数据在从停止位置恢复之前 AWS DMS 被处理或标记为已复制和备份，从而导致以下错误： ``` [SOURCE_CAPTURE ]E: Failed to access LSN '0000dbd9:0006f9ad:0003' in the backup log sets since BACKUP/LOG-s are not available. [1020465] (sqlserver_endpoint_capture.c:764) ``` 要缓解此问题，请按照之前的建议设置 `maxtrans` 和 `maxscans` 值。 # 使用微软 Azure SQL 数据库作为来源 AWS DMS 使用 AWS DMS，你可以像使用 SQL Server 一样使用微软 Azure SQL 数据库作为源。 AWS DMS 作为来源，支持本地或 Amazon EC2 实例上运行的 SQL Server 所支持的相同数据库版本列表。 有关更多信息，请参阅 [使用微软 SQL Server 数据库作为来源 AWS DMS](CHAP_Source.SQLServer.md)。 **注意** AWS DMS 不支持使用 Azure SQL 数据库进行更改数据捕获操作 (CDC)。 # 使用微软 Azure SQL 托管实例作为来源 AWS DMS 使用 AWS DMS，你可以使用 Microsoft Azure SQL 托管实例作为源，其方式与使用 SQL Server 的方式大致相同。 AWS DMS 作为来源，支持本地或 Amazon EC2 实例上运行的 SQL Server 所支持的相同数据库版本列表。 有关更多信息，请参阅 [使用微软 SQL Server 数据库作为来源 AWS DMS](CHAP_Source.SQLServer.md)。 # 使用适用于 PostgreSQL 灵活服务器的微软 Azure 数据库作为来源 AWS DMS 使用 AWS DMS，你可以使用适用于 PostgreSQL 灵活服务器的微软 Azure 数据库作为源，其方式与使用 PostgreSQL 的方式大致相同。 有关支持作为源的适用于 PostgreSQL 的 Microsoft Azure 数据库灵活服务器版本的信息 AWS DMS ，请参阅。[的来源 AWS DMS](CHAP_Introduction.Sources.md) ## 设置 Microsoft Azure Database for PostgreSQL 灵活服务器以进行逻辑复制和解码 在数据库迁移期间，您可以使用 Microsoft Azure Database for PostgreSQL 灵活服务器中的逻辑复制和解码功能。 对于逻辑解码，DMS 使用 `test_decoding` 或 `pglogical` 插件。如果 `pglogical` 插件在源 PostgreSQL 数据库上可用，则 DMS 使用 `pglogical` 创建复制插槽，否则使用 `test_decoding` 插件。 要将您的 Microsoft Azure for PostgreSQL 灵活服务器配置为 DMS 的来源端点，请执行以下步骤： 1. 在门户上打开“服务器参数”页面。 1. 将 `wal_level` 服务器参数设置为 `LOGICAL`。 1. 如果要使用 `pglogical` 扩展，请将 `shared_preload_libraries` 和 `azure.extensions` 参数设置为 `pglogical`。 1. 将 `max_replication_slots` 参数设置为您计划同时运行的最大 DMS 任务数。在 Microsoft Azure 中，此参数的默认值是 10。此参数的最大值取决于 PostgreSQL 实例的可用内存，每 GB 内存允许使用 2 到 8 个复制插槽。 1. 将 `max_wal_senders` 参数设置为一个大于 1 的值。`max_wal_senders` 参数用于设置可以运行的并发任务数。默认值是 10。 1. 将 `max_worker_processes` 参数值设置为至少 16。否则，您可能会看到如下错误： ``` WARNING: out of background worker slots. ``` 1. 保存更改。重启服务器以应用更改。 1. 确认您的 PostgreSQL 实例允许来自所连接资源的网络流量。 1. 使用以下命令向现有用户授予复制权限，或创建具有复制权限的新用户。 + 使用以下命令向现有用户授予复制权限： ``` ALTER USER WITH REPLICATION; ``` + 使用以下命令创建具有复制权限的新用户： ``` CREATE USER aws_dms_user PASSWORD 'aws_dms_user_password'; GRANT azure_pg_admin to aws_dms_user; ALTER ROLE aws_dms_user REPLICATION LOGIN; ``` 有关使用 PostgreSQL 的逻辑复制的更多信息，请参阅以下主题： + [使用逻辑复制启用更改数据捕获（CDC）](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.Security) + [使用本机 CDC 开始点设置 PostgreSQL 源的 CDC 加载](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.v10) + [Azure Database for PostgreSQL 文档](https://learn.microsoft.com/en-us/azure/postgresql/)中的[ Azure Database for PostgreSQL – 灵活服务器中的逻辑复制和逻辑解码](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/concepts-logical)。 # 使用适用于 MySQL 灵活服务器的微软 Azure 数据库作为来源 AWS DMS 使用 AWS DMS，你可以使用适用于 MySQL 的微软 Azure 数据库灵活服务器作为源，其方式与使用 MySQL 的方式大致相同。 有关 AWS DMS 支持作为源的微软 Azure 数据库适用于 MySQL 的灵活服务器版本的信息，请参阅[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 有关使用客户管理的 MySQL 兼容数据库的更多信息，请参阅。 AWS DMS[使用自管理的 MySQL 兼容数据库作为源 AWS DMS](CHAP_Source.MySQL.md#CHAP_Source.MySQL.CustomerManaged) ## 使用 Azure MySQL 作为源代码时的限制 AWS Database Migration Service + Azure MySQL 灵活服务器系统变量的默认值`sql_generate_invisible_primary_key`为`ON`，服务器会自动将生成的不可见主键 (GIPK) 添加到创建的任何没有显式主键的表中。 AWS DMS 不支持对具有 GIPK 限制的 MySQL 表进行持续复制。 # 使用 OCI MySQL Heatwave 作为来源 AWS DMS 使用 AWS DMS，你可以使用 OCI MySQL Heatwave 作为来源，其方式与使用 MySQL 的方式大致相同。使用 OCI MySQL Heatwave 作为来源需要进行一些额外的配置更改。 有关 AWS DMS 支持作为源的 OCI MySQL Heatwave 版本的信息，请参阅。[的来源 AWS DMS](CHAP_Introduction.Sources.md) ## 设置 OCI MySQL Heatwave 进行逻辑复制 要将您的 OCI MySQL Heatwave 实例配置为 DMS 的源端点，请执行以下操作： 1. 登录 OCI 控制台，然后打开左上角的主汉堡菜单（≡）。 1. 选择**数据库**、**数据库系统**。 1. 打开**配置**菜单。 1. 选择**创建配置**。 1. 输入配置名称，例如 **dms\$1configuration**。 1. 选择当前 OCI MySQL Heatwave 实例的形状。您可以在实例的**数据库系统配置**属性选项卡的**数据库系统配置：形状**部分下找到形状。 1. 在**用户变量**部分中，选择 `binlog_row_value_options` 系统变量。其默认值为 `PARTIAL_JSON`。清除该值。 1. 选择**创建**按钮。 1. 打开您的 OCI My SQLHeatwave 实例，然后选择**编辑**按钮。 1. 在**配置**部分，选择**更改配置**按钮，然后选择您在步骤 4 中创建的形状配置。 1. 更改生效后，实例便已准备就绪，可以进行逻辑复制。 # 使用适用于 MySQL 的谷歌云作为来源 AWS DMS 有了 AWS DMS，你可以使用适用于 MySQL 的 Google Cloud 作为来源，其方式与使用 MySQL 的方式大致相同。 有关 AWS DMS 支持作为源的 GCP MySQL 版本的信息，请参阅[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 有关更多信息，请参阅 [使用与 MySQL 兼容的数据库作为源 AWS DMS](CHAP_Source.MySQL.md)。 **注意** 3.4.6 AWS DMS 版本支持将 GCP MySQL 8.0 作为源代码。 AWS DMS 不支持 MySQL 实例`verify-full`的 GCP 的 SSL 模式。 `Allow only SSL connections`不支持 GCP MySQL 安全设置，因为它需要服务器和客户端证书验证。 AWS DMS 仅支持服务器证书验证。 AWS DMS 支持`binlog_checksum`数据库标志的默认 GCP CloudSQL for MySQL 值为。`CRC32` # 使用适用于 PostgreSQL 的谷歌云作为来源 AWS DMS 借助 AWS DMS，你可以使用适用于 PostgreSQL 的 Google Cloud 作为来源，其方式与使用自我管理 PostgreSQL 数据库的方式大致相同。 有关支持作为源代码的 GCP PostgreSQL 版本的信息 AWS DMS ，请参阅。[的来源 AWS DMS](CHAP_Introduction.Sources.md) 有关更多信息，请参阅 [使用 PostgreSQL 数据库作为源 AWS DMS](CHAP_Source.PostgreSQL.md)。 ## 设置 Google Cloud for PostgreSQL 以进行逻辑复制和解码 在数据库迁移期间，您可以使用 Google Cloud for PostgreSQL 中的逻辑复制和解码功能。 对于逻辑解码，DMS 使用以下插件之一： + `test_decoding` + `pglogical` 如果 `pglogical` 插件在源 PostgreSQL 数据库上可用，则 DMS 使用 `pglogical` 创建复制插槽，否则使用 `test_decoding` 插件。 请注意以下有关使用逻辑解码的 AWS DMS注意事项： 1. 使用 Google Cloud for PostgreSQL，通过将 `cloudsql.logical_decoding` 标志设置为 `on` 来启用逻辑解码。 1. 要启用 `pglogical`，请将 `cloudsql.enable_pglogical` 标志设置为 `on`，然后重新启动数据库。 1. 要使用逻辑解码功能，请使用 `REPLICATION` 属性创建一个 PostgreSQL 用户。使用 `pglogical` 扩展时，用户必须具有 `cloudsqlsuperuser` 角色。要创建具有 `cloudsqlsuperuser` 角色的用户，请执行以下操作： ``` CREATE USER new_aws_dms_user WITH REPLICATION IN ROLE cloudsqlsuperuser LOGIN PASSWORD 'new_aws_dms_user_password'; ``` 要在现有用户上设置此属性，请执行以下操作： ``` ALTER USER existing_user WITH REPLICATION; ``` 1. 将 `max_replication_slots` 参数设置为您计划同时运行的最大 DMS 任务数。在 Google Cloud SQL 中，此参数的默认值是 10。此参数的最大值取决于 PostgreSQL 实例的可用内存，每 GB 内存允许使用 2 到 8 个复制插槽。 有关使用 PostgreSQL 的逻辑复制的更多信息，请参阅以下主题： + [使用逻辑复制启用更改数据捕获（CDC）](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.Security) + [使用本机 CDC 开始点设置 PostgreSQL 源的 CDC 加载](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.v10) + [Cloud SQL for PostgreSQL 文档](https://cloud.google.com/sql/docs/postgres)中的[设置逻辑复制和解码](https://cloud.google.com/sql/docs/postgres/replication/configure-logical-replication)。 # 使用 PostgreSQL 数据库作为源 AWS DMS 您可以使用迁移一个或多个 PostgreSQL 数据库中的数据。 AWS DMS将 PostgreSQL 数据库作为源时，您可以将数据迁移到另一个 PostgreSQL 数据库或其他支持的数据库。 有关支持作为源代码的 PostgreSQL 版本的信息 AWS DMS ，请参阅。[的来源 AWS DMS](CHAP_Introduction.Sources.md) AWS DMS 对于以下类型的数据库，支持 PostgreSQL： +  本地数据库 + Amazon EC2 实例上的数据库 + Amazon RDS 数据库实例上的数据库 + 基于 Amazon Aurora PostgreSQL 兼容版的数据库实例上的数据库 + 基于 Amazon Aurora PostgreSQL 兼容无服务器版的数据库实例上的数据库 **注意** DMS 仅支持将 Amazon Aurora PostgreSQL – Serverless V1 作为完全加载的源。但您可以使用 Amazon Aurora PostgreSQL – Serverless V2 作为完全加载、完全加载 \$1 CDC 和仅限 CDC 的任务的源。 可以使用安全套接字层（SSL）加密 PostgreSQL 端点与复制实例之间的连接。有关将 SSL 用于 PostgreSQL 终端节点的更多信息，请参阅[将 SSL 与 AWS Database Migration Service](CHAP_Security.SSL.md)。 使用 PostgreSQL 作为源的附加安全要求是，指定的用户账户必须是 PostgreSQL 数据库中的注册用户。 要将 PostgreSQL 数据库配置为 AWS DMS 源端点，请执行以下操作： + 创建具有相应权限的 PostgreSQL 用户，以 AWS DMS 提供对您的 PostgreSQL 源数据库的访问权限。 **注意** 如果您的 PostgreSQL 源数据库是自管理数据库，请参阅[使用自我管理的 PostgreSQL 数据库作为源代码 AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites)了解更多信息。 如果您的 PostgreSQL 源数据库由 Amazon RDS 管理，请参阅[使用 AWS托管的 PostgreSQL 数据库作为 DMS 源](#CHAP_Source.PostgreSQL.RDSPostgreSQL)了解更多信息。 + 创建符合所选 PostgreSQL 数据库配置的 PostgreSQL 源端点。 + 创建一项或一组任务来迁移您的表。 要创建 full-load-only任务，无需进一步配置端点。 在创建更改数据捕获任务（仅 CDC，或者完全加载和 CDC 任务）之前，请参阅[使用自我管理的 PostgreSQL 数据库作为源启用 CDC AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites.CDC)或[使用 AWS托管的 PostgreSQL 数据库实例启用 CDC AWS DMS](#CHAP_Source.PostgreSQL.RDSPostgreSQL.CDC)。 **Topics** + [使用自我管理的 PostgreSQL 数据库作为源代码 AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites) + [使用 AWS托管的 PostgreSQL 数据库作为 DMS 源](#CHAP_Source.PostgreSQL.RDSPostgreSQL) + [使用逻辑复制启用更改数据捕获（CDC）](#CHAP_Source.PostgreSQL.Security) + [使用本机 CDC 开始点设置 PostgreSQL 源的 CDC 加载](#CHAP_Source.PostgreSQL.v10) + [使用从 PostgreSQL 迁移到 PostgreSQL AWS DMS](#CHAP_Source.PostgreSQL.Homogeneous) + [使用 Babelfish 为亚马逊 Aurora PostgreSQL 迁移 AWS DMS](#CHAP_Source.PostgreSQL.Babelfish) + [从 PostgreSQL 源数据库中移除 AWS DMS 构件](#CHAP_Source.PostgreSQL.CleanUp) + [将 PostgreSQL 数据库作为 DMS 源时的额外配置设置](#CHAP_Source.PostgreSQL.Advanced) + [只读副本作为 PostgreSQL 的源](#CHAP_Source.PostgreSQL.ReadReplica) + [使用 `MapBooleanAsBoolean` PostgreSQL 端点设置](#CHAP_Source.PostgreSQL.ConnectionAttrib.Endpointsetting) + [使用 PostgreSQL 作为 DMS 源时的端点设置和额外连接属性 (ECAs)](#CHAP_Source.PostgreSQL.ConnectionAttrib) + [将 PostgreSQL 数据库作为 DMS 源的限制](#CHAP_Source.PostgreSQL.Limitations) + [PostgreSQL 的源数据类型](#CHAP_Source-PostgreSQL-DataTypes) ## 使用自我管理的 PostgreSQL 数据库作为源代码 AWS DMS 使用自管理的 PostgreSQL 数据库作为源，您可以将数据迁移到另一个 PostgreSQL 数据库，也可以将数据迁移到支持的其他目标数据库。 AWS DMS数据库源可以是在 Amazon EC2 实例上运行的本地数据库，也可以是自管理引擎。您可以将数据库实例用于完全加载任务，也可以用于更改数据捕获（CDC）任务。 ### 使用自行管理的 PostgreSQL 数据库作为源的先决条件 AWS DMS 在从自管理 PostgreSQL 源数据库迁移数据之前，请执行以下操作： + 请确保使用版本为 9.4.x 或更高版本的 PostgreSQL 数据库。 + 对于完全加载加上 CDC 任务或仅限 CDC 任务，请向为 PostgreSQL 源数据库指定的用户账户授予超级用户权限。该用户账户访问源中特定于复制的函数需要超级用户权限。DMS 用户账户需要所有列的 SELECT 权限才能成功迁移表。如果缺少对列的权限，DMS 会使用常规 DMS 数据类型映射创建目标表，这会导致元数据差异和任务失败。 + 将 AWS DMS 复制服务器的 IP 地址添加到`pg_hba.conf`配置文件中，并启用复制和套接字连接。下面是一个示例。 ``` # Replication Instance host all all 12.3.4.56/00 md5 # Allow replication connections from localhost, by a user with the # replication privilege. host replication dms 12.3.4.56/00 md5 ``` PostgreSQL 的 `pg_hba.conf` 配置文件控制客户端身份验证。（HBA 代表基于主机的身份验证。） 文件通常存储在数据库集群的数据目录中。 + 如果您要使用将数据库配置为逻辑复制源， AWS DMS 请参阅 [使用自我管理的 PostgreSQL 数据库作为源启用 CDC AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites.CDC) **注意** 有些 AWS DMS 事务会闲置一段时间，然后才会让 DMS 引擎再次使用它们。在 PostgreSQL 版本 9.6 及更高版本中使用参数 `idle_in_transaction_session_timeout`，能够导致空闲事务超时并失败。当您使用 AWS DMS时，请勿结束空闲事务。 ### 使用自我管理的 PostgreSQL 数据库作为源启用 CDC AWS DMS AWS DMS 支持使用逻辑复制捕获变更数据 (CDC)。要启用自管理 PostgreSQL 源数据库的逻辑复制，请在 `postgresql.conf` 配置文件中设置以下参数和值： + 设置 `wal_level = logical`。 + 将 `max_replication_slots` 设置为一个大于 1 的值。 请根据您需要运行的任务数设置 `max_replication_slots` 值。例如，要运行五个任务，您需要设置至少五个时隙。在任务启动时时隙立即打开，即使任务不再运行仍保持打开。请务必手动删除空闲时隙。请注意，如果 DMS 创建了时隙，在删除任务后，DMS 会自动删除重复的时隙。 + 将 `max_wal_senders` 设置为一个大于 1 的值。 `max_wal_senders` 参数用于设置可以运行的并发任务数。 + `wal_sender_timeout` 参数会终止处于不活动状态的时间超过指定毫秒数的复制连接。本地 PostgreSQL 数据库的默认值为 60000 毫秒（60 秒）。将此值设置为 0（零）会禁用超时机制，这是 DMS 的有效设置。 将 `wal_sender_timeout` 设置为非零值时，执行 CDC 的 DMS 任务至少需要 10000 毫秒（10 秒），如果此值小于 10000，则任务会失败。将此值保持至少 5 分钟，以免在 DMS 复制实例执行多可用区失效转移期间造成延迟。 有些参数是静态的，只能在服务器启动时设置。在服务器重新启动之前，对配置文件（对于自管理数据库）或数据库参数组（对于 RDS for PostgreSQL 数据库）中的条目所做的任何更改都将被忽略。有关更多信息，请参阅 [PostgreSQL 文档](https://www.postgresql.org/docs/current/intro-whatis.html)。 有关启用 CDC 的更多信息，请参阅[使用逻辑复制启用更改数据捕获（CDC）](#CHAP_Source.PostgreSQL.Security)。 ## 使用 AWS托管的 PostgreSQL 数据库作为 DMS 源 您可以使用 AWS托管的 PostgreSQL 数据库实例作为源。 AWS DMS您可以使用 AWS托管的 PostgreSQL 源执行完全加载任务和更改数据捕获（CDC）任务。 ### 使用 AWS托管的 PostgreSQL 数据库作为 DMS 源的先决条件 从 AWS托管的 PostgreSQL 源数据库迁移数据之前，请执行以下操作： + 我们建议您使用具有 PostgreSQL 数据库实例所需最低权限的 AWS 用户账户作为 PostgreSQL 源终端节点的用户账户。 AWS DMS建议不要使用主账户。该账户必须具有 `rds_superuser` 和 `rds_replication` 角色。`rds_replication` 角色可授予管理逻辑时隙和使用逻辑时隙流式处理数据的权限。 请务必使用您所用账户的主用户账户创建多个对象。有关创建这些项目的信息，请参阅[不使用主用户账户迁移 Amazon RDS for PostgreSQL 数据库](#CHAP_Source.PostgreSQL.RDSPostgreSQL.NonMasterUser)。 + 如果源数据库位于虚拟私有云（VPC）中，请选择一个 VPC 安全组，该安全组提供对数据库所在的数据库实例的访问权限。这是 DMS 复制实例成功连接到源数据库实例所必需的。当数据库和 DMS 复制实例位于同一 VPC 中时，将相应的安全组添加到其自己的入站规则中。 **注意** 有些 AWS DMS 事务会闲置一段时间，然后才会让 DMS 引擎再次使用它们。在 PostgreSQL 版本 9.6 及更高版本中使用参数 `idle_in_transaction_session_timeout`，能够导致空闲事务超时并失败。当您使用 AWS DMS时，请勿结束空闲事务。 ### 使用 AWS托管的 PostgreSQL 数据库实例启用 CDC AWS DMS AWS DMS 当数据库实例配置为使用逻辑复制时，支持 Amazon RDS PostgreSQL 数据库上的 CDC。下表汇总了每个 AWS托管的 PostgreSQL 版本的逻辑复制兼容性。 | PostgreSQL 版本 | AWS DMS 满载支持 | AWS DMS CDC 支持 | | --- | --- | --- | | Aurora PostgreSQL 版本 2.1（与 PostgreSQL 10.5 兼容）或更低版本 | 是 | 否 | | Aurora PostgreSQL 版本 2.2（与 PostgreSQL 10.6 兼容）或更高版本 | 支持 | 是 | | RDS for PostgreSQL（与 PostgreSQL 10.21 兼容）或更高版本 | 支持 | 是 | **为 RDS PostgreSQL 数据库实例启用逻辑复制** 1. 使用 Po AWS stgreSQL 数据库实例的主用户账户作为 PostgreSQL 源终端节点的用户账户。主用户账户具有允许它设置 CDC 所需的角色。 如果您使用主用户账户之外的账户，请确保从要使用的账户的主账户创建多个对象。有关更多信息，请参阅 [不使用主用户账户迁移 Amazon RDS for PostgreSQL 数据库](#CHAP_Source.PostgreSQL.RDSPostgreSQL.NonMasterUser)。 1. 在数据库集群参数组中将 `rds.logical_replication` 参数设置为 1。此静态参数要求重启数据库实例才能生效。在应用该参数期间， AWS DMS 设置 `wal_level`、`max_wal_senders`、`max_replication_slots` 和 `max_connections` 参数。这些参数更改可以增加预写日志 (WAL) 生成，因此，只有在您使用逻辑复制槽时才设置 `rds.logical_replication`。 1. `wal_sender_timeout` 参数会终止处于不活动状态的时间超过指定毫秒数的复制连接。 AWS由托管的 PostgreSQL 数据库的默认值为 30000 毫秒（30 秒）。将此值设置为 0（零）会禁用超时机制，这是 DMS 的有效设置。 将 `wal_sender_timeout` 设置为非零值时，执行 CDC 的 DMS 任务至少需要 10000 毫秒（10 秒），如果此值介于 0 和 10000 之间，则会失败。将此值保持至少 5 分钟，以免在 DMS 复制实例执行多可用区失效转移期间造成延迟。 1. 确保数据库集群参数组中 `max_worker_processes` 参数的值大于或等于 `max_logical_replication_workers`、`autovacuum_max_workers` 和 `max_parallel_workers` 的总组合值。大量后台工作进程可能会影响小型实例上的应用程序工作负载。因此，如果为 `max_worker_processes` 设置的值高于默认值，请监控数据库的性能。 1. 使用 Aurora PostgreSQL 作为 CDC 的源时，请将 `synchronous_commit` 设置为 `ON`。 **将 PostgreSQL 多可用区数据库集群只读副本用于 CDC（正在进行的复制）** 1. 在数据库集群参数组中将 `rds.logical_replication` 和 `sync_replication_slots` 参数设置为 1。此静态参数要求重启数据库实例才能生效。 1. 运行以下命令在 Writer 上创建 `awsdms_ddl_audit` 表，并将 `objects_schema` 替换为要使用的架构的名称： ``` CREATE TABLE objects_schema.awsdms_ddl_audit ( c_key bigserial primary key, c_time timestamp, -- Informational c_user varchar(64), -- Informational: current_user c_txn varchar(16), -- Informational: current transaction c_tag varchar(24), -- Either 'CREATE TABLE' or 'ALTER TABLE' or 'DROP TABLE' c_oid integer, -- For future use - TG_OBJECTID c_name varchar(64), -- For future use - TG_OBJECTNAME c_schema varchar(64), -- For future use - TG_SCHEMANAME. For now - holds current_schema c_ddlqry text -- The DDL query associated with the current DDL event ); ``` 1. 运行以下命令以创建 `awsdms_intercept_ddl` 函数，并将 `objects_schema` 替换为要使用的架构的名称： ``` CREATE OR REPLACE FUNCTION objects_schema.awsdms_intercept_ddl() RETURNS event_trigger LANGUAGE plpgsql SECURITY DEFINER AS $$ declare _qry text; BEGIN if (tg_tag='CREATE TABLE' or tg_tag='ALTER TABLE' or tg_tag='DROP TABLE' or tg_tag = 'CREATE TABLE AS') then SELECT current_query() into _qry; insert into objects_schema.awsdms_ddl_audit values ( default,current_timestamp,current_user,cast(TXID_CURRENT()as varchar(16)),tg_tag,0,'',current_schema,_qry ); delete from objects_schema.awsdms_ddl_audit; end if; END; $$; ``` 1. 运行以下命令以创建 `awsdms_intercept_ddl` 事件触发器： ``` CREATE EVENT TRIGGER awsdms_intercept_ddl ON ddl_command_end EXECUTE PROCEDURE objects_schema.awsdms_intercept_ddl(); ``` 确保访问这些事件的所有用户和角色都具有必要的 DDL 权限。例如： ``` grant all on public.awsdms_ddl_audit to public; grant all on public.awsdms_ddl_audit_c_key_seq to public; ``` 1. 在 Writer 上创建复制槽位： ``` SELECT * FROM pg_create_logical_replication_slot('dms_read_replica_slot', 'test_decoding', false, true); ``` 1. 确保 Reader 上的复制槽位可用： ``` select * from pg_catalog.pg_replication_slots where slot_name = 'dms_read_replica_slot'; slot_name |plugin |slot_type|datoid|database|temporary|active|active_pid|xmin|catalog_xmin|restart_lsn|confirmed_flush_lsn|wal_status|safe_wal_size|two_phase|inactive_since |conflicting|invalidation_reason|failover|synced| ---------------------+-------------+---------+------+--------+---------+------+----------+----+------------+-----------+-------------------+----------+-------------+---------+-----------------------------+-----------+-------------------+--------+------+ dms_read_replica_slot|test_decoding|logical | 5|postgres|false |false | | |3559 |0/180011B8 |0/180011F0 |reserved | |true |2025-02-10 15:45:04.083 +0100|false | |false |false | ``` 1. 为只读副本创建 DMS 源端点并通过额外连接属性设置逻辑复制槽位名称： ``` slotName=dms_read_replica_slot; ``` 1. 创建并启动 CDC/FL\$1CDC 任务。 **注意** 对于 CDC/FL\$1CDC 迁移，DMS 将任务开始时间视为 CDC 起始位置。复制槽 LSNs 中的所有较旧版本都将被忽略。 ### 不使用主用户账户迁移 Amazon RDS for PostgreSQL 数据库 在某些情况下，您可能不会将主用户账户用于将作为源的 Amazon RDS PostgreSQL 数据库实例。在这些情况下，您需要创建多个对象来捕获数据定义语言（DDL）事件。您可以在主用户账户之外的账户中创建这些对象，然后在主用户账户中创建触发器。 **注意** 如果在源端点上将 `CaptureDdls` 端点设置为 `false`，您不需要在源数据库上创建以下表和触发器。 使用以下过程创建这些对象。 **创建对象** 1. 选择要在其中创建对象的架构。默认架构为 `public`。确保架构存在并且可由 `OtherThanMaster` 账户访问。 1. 使用除主账户之外的用户账户（此处为 `OtherThanMaster` 账户）登录 PostgreSQL 数据库实例。 1. 运行以下命令以创建表 `awsdms_ddl_audit`，并将以下代码中的 `objects_schema` 替换为要使用的架构名称。 ``` CREATE TABLE objects_schema.awsdms_ddl_audit ( c_key bigserial primary key, c_time timestamp, -- Informational c_user varchar(64), -- Informational: current_user c_txn varchar(16), -- Informational: current transaction c_tag varchar(24), -- Either 'CREATE TABLE' or 'ALTER TABLE' or 'DROP TABLE' c_oid integer, -- For future use - TG_OBJECTID c_name varchar(64), -- For future use - TG_OBJECTNAME c_schema varchar(64), -- For future use - TG_SCHEMANAME. For now - holds current_schema c_ddlqry text -- The DDL query associated with the current DDL event ); ``` 1. 运行以下命令以创建函数 `awsdms_intercept_ddl`，并将以下代码中的 `objects_schema` 替换为要使用的架构名称。 ``` CREATE OR REPLACE FUNCTION objects_schema.awsdms_intercept_ddl() RETURNS event_trigger LANGUAGE plpgsql SECURITY DEFINER AS $$ declare _qry text; BEGIN if (tg_tag='CREATE TABLE' or tg_tag='ALTER TABLE' or tg_tag='DROP TABLE' or tg_tag = 'CREATE TABLE AS') then SELECT current_query() into _qry; insert into objects_schema.awsdms_ddl_audit values ( default,current_timestamp,current_user,cast(TXID_CURRENT()as varchar(16)),tg_tag,0,'',current_schema,_qry ); delete from objects_schema.awsdms_ddl_audit; end if; END; $$; ``` 1. 注销 `OtherThanMaster` 账户并使用分配了 `rds_superuser` 角色的账户登录。 1. 运行以下命令以创建事件触发器 `awsdms_intercept_ddl`。 ``` CREATE EVENT TRIGGER awsdms_intercept_ddl ON ddl_command_end EXECUTE PROCEDURE objects_schema.awsdms_intercept_ddl(); ``` 1. 确保访问这些事件的所有用户和角色都具有必要的 DDL 权限。例如： ``` grant all on public.awsdms_ddl_audit to public; grant all on public.awsdms_ddl_audit_c_key_seq to public; ``` 在完成前面的过程后，可以使用 `OtherThanMaster` 账户创建 AWS DMS 源终端节点。 **注意** 这些事件由 `CREATE TABLE`、`ALTER TABLE` 和 `DROP TABLE` 语句触发。 ## 使用逻辑复制启用更改数据捕获（CDC） 在 PostgreSQL 源的数据库迁移期间，您可以使用 PostgreSQL 的本机逻辑复制功能启用更改数据捕获（CDC）。您可以将此功能与自管理 PostgreSQL 数据库实例以及 Amazon RDS for PostgreSQL SQL 数据库实例一起使用。这种方法可减少停机时间，并确保目标数据库与源 PostgreSQL 数据库同步。 AWS DMS 支持使用主键的 PostgreSQL 表的 CDC。如果某个表没有主键，提前写入日志（WAL）将不包含数据库行的前映像。在这种情况下，DMS 无法更新此表。在这里，您可以使用其他配置设置，并使用表副本身份作为解决方法。但是，这种方法可能会生成额外的日志。我们建议您仅在仔细测试后才使用表副本身份作为解决方法。有关更多信息，请参阅 [将 PostgreSQL 数据库作为 DMS 源时的额外配置设置](#CHAP_Source.PostgreSQL.Advanced)。 **注意** 逻辑解码插件支持 REPLICA IDENTITY FULL，但 pglogical 插件不支持。有关更多信息，请参阅 [pglogical 文档](https://github.com/2ndQuadrant/pglogical#primary-key-or-replica-identity-required)。 对于满载任务以及仅限 CDC 和 CDC 的任务， AWS DMS 使用逻辑复制槽保留 WAL 日志以进行复制，直到日志被解码。对于完全加载和 CDC 任务或仅限 CDC 的任务，在重启（而非恢复）时，系统会重新创建复制槽。 **注意** 对于逻辑解码，DMS 使用 test\$1decoding 或 pglogical 插件。如果 pglogical 插件在源 PostgreSQL 数据库上可用，DMS 会使用 pglogical 创建复制插槽，否则使用 test\$1decoding 插件。有关 test\$1decoding 插件的更多信息，请参阅 [PostgreSQL 文档](https://www.postgresql.org/docs/9.4/test-decoding.html)。 如果将数据库参数 `max_slot_wal_keep_size` 设置为非默认值，并且复制槽的 `restart_lsn` 落后于当前 LSN 的大小超过此大小，DMS 任务会因为删除了所需的 WAL 文件而失败。 ### 配置 pglogical 插件 pglogical 插件是作为 PostgreSQL 扩展实现的，是一种逻辑复制系统和选择性数据复制模型。下表列出了支持 pglogical 插件的源 PostgreSQL 数据库版本。 | PostgreSQL 源 | 支持 pglogical | | --- | --- | | 自管理 PostgreSQL 9.4 或更高版本 | 是 | | Amazon RDS PostgreSQL 9.5 或更低版本 | 否 | | Amazon RDS PostgreSQL 9.6 或更高版本 | 是 | | Aurora PostgreSQL 1.x 到 2.5.x | 否 | | Aurora PostgreSQL 2.6.x 或更高版本 | 是 | | Aurora PostgreSQL 3.3.x 或更高版本 | 是 | 在配置 pglogical 以与一起使用之前 AWS DMS，请先在 PostgreSQL 源数据库上启用更改数据捕获 (CDC) 的逻辑复制。 + 有关在*自管理* PostgreSQL 源数据库上为 CDC 启用逻辑复制的信息，请参阅[使用自我管理的 PostgreSQL 数据库作为源启用 CDC AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites.CDC)。 + 有关在 *AWS托管的* PostgreSQL 源数据库上为 CDC 启用逻辑复制的信息，请参阅[使用 AWS托管的 PostgreSQL 数据库实例启用 CDC AWS DMS](#CHAP_Source.PostgreSQL.RDSPostgreSQL.CDC)。 在 PostgreSQL 源数据库上启用逻辑复制后，请使用以下步骤配置用于 DMS 的 pglogical。 **使用 pglogical 插件在 PostgreSQL 源数据库上进行逻辑复制 AWS DMS** 1. 在 PostgreSQL 源数据库上创建一个 pglogical 扩展： 1. 设置正确的参数： + 对于自管理 PostgreSQL 数据库，请设置数据库参数 `shared_preload_libraries= 'pglogical'`。 + 对于 Amazon RDS 上的 PostgreSQL 和 Amazon Aurora PostgreSQL 兼容版数据库，请在同一个 RDS 参数组中将参数 `shared_preload_libraries` 设置为 `pglogical`。 1. 重启您的 PostgreSQL 源数据库。 1. 在 PostgreSQL 数据库上，运行此命令 `create extension pglogical;`。 1. 运行以下命令验证是否已成功安装 pglogical： `select * FROM pg_catalog.pg_extension` 现在，您可以创建一个 AWS DMS 任务，为 PostgreSQL 源数据库端点执行更改数据捕获。 **注意** 如果您未在 PostgreSQL 源数据库上启用 pglogical， AWS DMS 默认使用 `test_decoding` 插件。当启用 pglogical 进行逻辑解码时，默认情况下 AWS DMS 使用 pglogical。但是您可以设置额外连接属性，`PluginName` 会改用 `test_decoding` 插件。 ## 使用本机 CDC 开始点设置 PostgreSQL 源的 CDC 加载 要使用 PostgreSQL 作为源启用本机 CDC 开始点，请在创建端点时将 `slotName` 额外连接属性设置为现有逻辑复制槽的名称。此逻辑复制槽保留从创建终端节点时起持续进行的更改，因此它支持从前一个时间点进行复制。 PostgreSQL 将数据库更改写入 WAL 文件，这些文件只有在 AWS DMS 成功读取逻辑复制槽中的更改后才会丢弃。使用逻辑复制槽可以防止记录的更改在它们被复制引擎使用之前删除。 但是，根据更改速率和消耗量，保留在逻辑复制槽中的更改可能会导致磁盘使用率提高。我们建议您在使用逻辑复制槽时，在源 PostgreSQL 实例中设置空间使用情况警报。有关设置 `slotName` 额外连接属性的更多信息，请参阅 [使用 PostgreSQL 作为 DMS 源时的端点设置和额外连接属性 (ECAs)](#CHAP_Source.PostgreSQL.ConnectionAttrib)。 以下过程将更详细地演练这种方法。 **使用本机 CDC 开始点设置 PostgreSQL 源终端节点的 CDC 加载** 1. 确定您要用作开始点的更早复制任务（父任务）所使用的逻辑复制槽。然后，查询源数据库上的 `pg_replication_slots` 视图，以确保此槽位没有任何活动的连接。如果有，请先予以解决并关闭它们，然后再继续。 对于以下步骤，假定您的逻辑复制槽为 `abc1d2efghijk_34567890_z0yx98w7_6v54_32ut_1srq_1a2b34c5d67ef`。 1. 创建一个新的源终端节点，其中包含以下额外连接属性设置。 ``` slotName=abc1d2efghijk_34567890_z0yx98w7_6v54_32ut_1srq_1a2b34c5d67ef; ``` 1. 使用控制台 AWS CLI 或 AWS DMS API 创建仅限 CDC 的新任务。例如，通过使用 CLI，您可以运行以下 `create-replication-task` 命令。 ``` aws dms create-replication-task --replication-task-identifier postgresql-slot-name-test --source-endpoint-arn arn:aws:dms:us-west-2:012345678901:endpoint:ABCD1EFGHIJK2LMNOPQRST3UV4 --target-endpoint-arn arn:aws:dms:us-west-2:012345678901:endpoint:ZYX9WVUTSRQONM8LKJIHGF7ED6 --replication-instance-arn arn:aws:dms:us-west-2:012345678901:rep:AAAAAAAAAAA5BB4CCC3DDDD2EE --migration-type cdc --table-mappings "file://mappings.json" --cdc-start-position "4AF/B00000D0" --replication-task-settings "file://task-pg.json" ``` 在前面的命令中，设置了以下选项： + `source-endpoint-arn` 选项设置为您在步骤 2 中创建的新值。 + `replication-instance-arn` 选项设置为与步骤 1 中的父任务相同的值。 + `table-mappings` 和 `replication-task-settings` 选项设置为与步骤 1 中的父任务相同的值。 + `cdc-start-position` 选项设置为起始位置值。要查找此起始位置，请查询源数据库上的 `pg_replication_slots` 视图，或查看步骤 1 中父任务的控制台详细信息。有关更多信息，请参阅 [确定 CDC 本机开始点](CHAP_Task.CDC.md#CHAP_Task.CDC.StartPoint.Native)。 要在使用控制 AWS DMS 台创建仅限 CDC 的新任务时启用自定义 CDC 启动模式，请执行以下操作： + 在**任务设置**部分，对于**源事务的 CDC 启动模式**，请选择**启用自定义 CDC 启动模式**。 + 对于**源事务的自定义 CDC 开始点**，请选择**指定日志序列号**。指定系统更改号或选择**指定恢复检查点**，然后提供恢复检查点。 当此 CDC 任务运行时，如果指定的逻辑复制槽不存在，则会 AWS DMS 引发错误。如果未使用有效的 `cdc-start-position` 设置创建任务，它也会引发错误。 在 pglogical 插件中使用本机 CDC 开始点并且想要使用新的复制槽时，请在创建 CDC 任务之前完成以下设置步骤。 **使用以前未在另一个 DMS 任务中创建的新复制槽** 1. 创建复制槽，如下所示： ``` SELECT * FROM pg_create_logical_replication_slot('replication_slot_name', 'pglogical'); ``` 1. 数据库创建复制槽后，将获取并记下此槽的 **restart\$1lsn** 和 **confirmed\$1flush\$1lsn** 值： ``` select * from pg_replication_slots where slot_name like 'replication_slot_name'; ``` 请注意，在复制槽之后创建的 CDC 任务的本机 CDC 开始位置不能早于 **confirmed\$1flush\$1lsn** 值。 有关 **restart\$1lsn** 和 **confirmed\$1flush\$1lsn** 值的信息，请参阅 [pg\$1replication\$1slots](https://www.postgresql.org/docs/14/view-pg-replication-slots.html) 1. 创建一个 pglogical 节点。 ``` SELECT pglogical.create_node(node_name := 'node_name', dsn := 'your_dsn_name'); ``` 1. 使用 `pglogical.create_replication_set` 函数创建两个复制集。第一个复制集跟踪有主键的表的更新和删除。第二个复制集仅跟踪插入，其名称与第一个复制集相同，只是添加了前缀“i”。 ``` SELECT pglogical.create_replication_set('replication_slot_name', false, true, true, false); SELECT pglogical.create_replication_set('ireplication_slot_name', true, false, false, true); ``` 1. 向复制集添加表。 ``` SELECT pglogical.replication_set_add_table('replication_slot_name', 'schemaname.tablename', true); SELECT pglogical.replication_set_add_table('ireplication_slot_name', 'schemaname.tablename', true); ``` 1. 创建源端点时，请设置以下额外连接属性（ECA）。 ``` PluginName=PGLOGICAL;slotName=slot_name; ``` 现在，您可以使用新的复制槽创建具有 PostgreSQL 本机开始点的仅限 CDC 的任务。有关 pglogical 插件的更多信息，请参阅 [pglogical 3.7 文档](https://www.enterprisedb.com/docs/pgd/3.7/pglogical/)。 ## 使用从 PostgreSQL 迁移到 PostgreSQL AWS DMS 当你从 PostgreSQL 以外的数据库引擎迁移到 PostgreSQL 数据库时 AWS DMS ，几乎总是最好的迁移工具。但是，当您从 PostgreSQL 数据库迁移到 PostgreSQL 数据库时，PostgreSQL 工具的效率更高。 ### 使用 PostgreSQL 本机工具迁移数据 我们建议您在以下条件下使用 PostgreSQL 数据库迁移工具（例如 `pg_dump`）： + 您有一个从源 PostgreSQL 数据库向目标 PostgreSQL 数据库的同构迁移。 + 您正在迁移整个数据库。 + 利用这些本机工具，可以在迁移您的数据时最大程度地减少停机时间。 pg\$1dump 实用程序使用 COPY 命令创建 PostgreSQL 数据库的架构和数据转储。pg\$1dump 生成的转储脚本将数据加载到一个同名的数据库中，然后重新创建表、索引和外键。要将数据恢复到具有不同名称的数据库，您可以使用 `pg_restore` 命令和 `-d` 参数。 如果您要将数据从在 EC2 上运行的 PostgreSQL 源数据库迁移到 Amazon RDS for PostgreSQL 目标，则可以使用 pglogical 插件。 有关将 PostgreSQL 数据库导入 Amazon RDS for PostgreSQL 或 Amazon Aurora PostgreSQL 兼容版的更多信息，请参阅[https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Procedural.Importing.html](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Procedural.Importing.html)。 ### 使用 DMS 将数据从 PostgreSQL 迁移到 PostgreSQL AWS DMS 例如，可以将数据从本地的 PostgreSQL 源数据库迁移到适用于 PostgreSQL 的目标 Amazon RDS 或 Aurora PostgreSQL 实例。核心或基本 PostgreSQL 数据类型通常可以成功迁移。 **注意** 将分区表从 PostgreSQL 源复制到 PostgreSQL 目标时，您无需在 DMS 任务的选择标准中提及父表。提及父表会导致目标上子表中的数据重复，这可能造成 PK 违规。在表映射选择标准中单独选择子表，即会自动填充父表。 源数据库支持但目标数据库不支持的数据类型可能无法成功迁移。 AWS DMS 如果数据类型未知，则将某些数据类型作为字符串流式传输。对于某些数据类型（例如 XML 和 JSON），如果文件较小则可以成功迁移，但如果是较大的文档，迁移会失败。 执行数据类型迁移时，需要注意以下事项： + 某些情况下，PostgreSQL NUMERIC(p,s) 数据类型不指定任何精度和小数位数。对于 DMS 版本 3.4.2 及更早版本，DMS 默认使用的精度为 28，小数位数为 6，即 NUMERIC(28,6)。例如，源中的值 0.611111104488373 在 PostgreSQL 目标中将转换为 0.611111。 + 数据类型为 ARRAY 的表必须具有主键。缺少主键的 ARRAY 数据类型的表在完全加载期间会暂停。 下表显示了源 PostgreSQL 数据类型以及是否可以成功迁移这些数据类型。 | 数据类型 | 成功迁移 | 部分迁移 | 不迁移 | 评论 | | --- | --- | --- | --- | --- | | INTEGER | X | | | | | SMALLINT | X | | | | | BIGINT | X | | | | | NUMERIC/DECIMAL(p,s) | | X | | 当 038 或 p=s=0 | | REAL | X | | | | | DOUBLE | X | | | | | SMALLSERIAL | X | | | | | SERIAL | X | | | | | BIGSERIAL | X | | | | | MONEY | X | | | | | CHAR | | X | | 未指定精度 | | CHAR(n) | X | | | | | VARCHAR | | X | | 未指定精度 | | VARCHAR (n) | X | | | | | TEXT | X | | | | | BYTEA | X | | | | | TIMESTAMP | X | | | 正无穷值和负无穷值分别被截断为“9999-12-31 23:59:59”和“4713-01-01 00:00:00 BC”。 | | TIMESTAMP（有时区） | | X | | | | DATE | X | | | | | TIME | X | | | | | 带时区的时间 | X | | | | | INTERVAL | | X | | | | BOOLEAN | X | | | | | ENUM | | | X | | | CIDR | X | | | | | INET | | | X | | | MACADDR | | | X | | | TSVECTOR | | | X | | | TSQUERY | | | X | | | XML | | X | | | | POINT | X | | | PostGIS 空间数据类型 | | LINE | | | X | | | LSEG | | | X | | | BOX | | | X | | | 路径 | | | X | | | POLYGON | X | | | PostGIS 空间数据类型 | | CIRCLE | | | X | | | JSON | | X | | | | ARRAY | X | | | 需要主键 | | COMPOSITE | | | X | | | RANGE | | | X | | | LINESTRING | X | | | PostGIS 空间数据类型 | | MULTIPOINT | X | | | PostGIS 空间数据类型 | | MULTILINESTRING | X | | | PostGIS 空间数据类型 | | MULTIPOLYGON | X | | | PostGIS 空间数据类型 | | GEOMETRYCOLLECTION | X | | | PostGIS 空间数据类型 | ### 迁移 PostGIS 空间数据类型 *空间数据* 标识空间中对象或位置的几何信息。PostgreSQL 对象关系数据库支持 PostGIS 空间数据类型。 在迁移 PostgreSQL 空间数据对象之前，请确保在全局级别启用 PostGIS 插件。这样做可以确保为 PostgreSQL 目标数据库实例 AWS DMS 创建精确的源空间数据列。 对于 PostgreSQL 到 PostgreSQL 的同构 AWS DMS 迁移，支持 PostGIS 几何和地理（大地坐标）数据对象类型和子类型的迁移，例如： + POINT + LINESTRING + POLYGON + MULTIPOINT + MULTILINESTRING + MULTIPOLYGON + GEOMETRYCOLLECTION ## 使用 Babelfish 为亚马逊 Aurora PostgreSQL 迁移 AWS DMS 你可以使用将 Babelfish for Aurora PostgreSQL 源表迁移到任何支持的目标终端节点。 AWS DMS 在使用 DMS 控制台、API 或 CLI 命令创建 AWS DMS 源终端节点时，将源设置为 **Amazon Aurora PostgreSQL**，将数据库名称设置为。**babelfish\$1db**在 **“端点设置”** 部分中，确保设置**DatabaseMode**为 **Babelfish**，并将其**BabelfishDatabaseName**设置为源 Babelfish T-SQL 数据库的名称。使用 Aurora PostgreSQL TCP 端口 **5432**，而不使用 Babelfish TCP 端口 **1433**。 迁移数据之前必须先创建表，以确保 DMS 使用正确的数据类型和表元数据。如果您在运行迁移之前未在目标上创建表，DMS 可能会使用不正确的数据类型和权限创建表。 ### 向迁移任务添加转换规则 在为 Babelfish 源创建迁移任务时，需要包含转换规则，以确保 DMS 使用预先创建的目标表。 如果您在定义 Babelfish for PostgreSQL 集群时设置了多数据库迁移模式，请添加将架构名称重命名为 T-SQL 架构的转换规则。例如，如果 T-SQL 架构名称为 `dbo`，而您的 Babelfish for PostgreSQL 架构名称为 `mydb_dbo`，则使用转换规则将架构重命名为 `dbo`。要查找 PostgreSQL 架构名称，请参阅《Amazon Aurora 用户指南》**中的 [Babelfish 架构](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/babelfish-architecture.html)。 如果您使用单数据库模式，则无需使用转换规则即可重命名数据库架构。PostgreSQL 架构名称与 T-SQL 数据库中的架构名称存在映射。 one-to-one 以下转换规则示例显示了如何将架构名称从 `mydb_dbo` 重命名回 `dbo`： ``` { "rules": [ { "rule-type": "transformation", "rule-id": "566251737", "rule-name": "566251737", "rule-target": "schema", "object-locator": { "schema-name": "mydb_dbo" }, "rule-action": "rename", "value": "dbo", "old-value": null }, { "rule-type": "selection", "rule-id": "566111704", "rule-name": "566111704", "object-locator": { "schema-name": "mydb_dbo", "table-name": "%" }, "rule-action": "include", "filters": [] } ] } ``` ### 使用包含 Babelfish 表的 PostgreSQL 源端点的限制 使用包含 Babelfish 表的 PostgreSQL 源端点时，存在以下限制： + DMS 仅支持从 Babelfish 版本 16.2/15.6 及更高版本以及 DMS 版本 3.5.3 及更高版本迁移。 + DMS 不会将 Babelfish 表定义更改复制到目标端点。解决此限制的一种方法是先将表定义更改应用于目标，然后在 Babelfish 源上更改表定义。 + 当您创建数据类型为 BYTEA 的 Babelfish 表时，DMS 会在迁移到作为目标的 SQL Server 时将这些表转换为 `varbinary(max)` 数据类型。 + DMS 不支持对二进制数据类型使用完整 LOB 模式，而是对二进制数据类型使用受限 LOB 模式。 + 当 Babelfish 作为源时，DMS 不支持数据验证。 + 对于**目标表准备模式**任务设置，仅使用**不执行任何操作**或**截断**模式。不要使用**删除目标中的表**模式。使用**删除目标中的表**时，DMS 可能会使用不正确的数据类型创建表。 + 使用持续复制（CDC 或完全加载和 CDC）时，请将 `PluginName` 额外连接属性（ECA）设置为 `TEST_DECODING`。 + 当 Babelfish 作为源时，DMS 不支持复制（CDC 或完全加载和 CDC）分区表。 ## 从 PostgreSQL 源数据库中移除 AWS DMS 构件 要捕获 DDL 事件，请在迁 AWS DMS 移任务启动时在 PostgreSQL 数据库中创建各种构件。完成任务后，您可能需要删除这些项目。 要删除项目，请发布以下语句（按显示顺序），`{AmazonRDSMigration}` 是在其中创建项目的架构：在删除架构时应尤为谨慎。请勿删除正在使用的架构，特别是非公有的操作架构。 ``` drop event trigger awsdms_intercept_ddl; ``` 事件触发器不属于特定架构。 ``` drop function {AmazonRDSMigration}.awsdms_intercept_ddl() drop table {AmazonRDSMigration}.awsdms_ddl_audit drop schema {AmazonRDSMigration} ``` ## 将 PostgreSQL 数据库作为 DMS 源时的额外配置设置 在从 PostgreSQL 数据库迁移数据时，您可以使用两种方法来添加额外配置设置： + 您可以将值添加到额外连接属性来捕获 DDL 事件，以及指定在其中创建操作 DDL 数据库项目的架构。有关更多信息，请参阅 [使用 PostgreSQL 作为 DMS 源时的端点设置和额外连接属性 (ECAs)](#CHAP_Source.PostgreSQL.ConnectionAttrib)。 + 您可以覆盖连接字符串参数。选择此选项可执行以下任一操作： + 指定内部 AWS DMS 参数。此类参数很少需要，因此不在用户界面中公开。 + 为特定数据库客户端指定直通（直通）值。 AWS DMS 在传递给数据库客户端的连接 sting 中包含直通参数。 + 通过在 `REPLICA IDENTITY` PostgreSQL 9.4 及更高版本中使用表级参数，您可以控制写入预写日志 () 的信息。WALs特别是，它这样做是为了 WALs 识别已更新或删除的行。 `REPLICA IDENTITY FULL`记录该行中所有列的旧值。请`REPLICA IDENTITY FULL`谨慎使用每张表，因为 WALs可能不需要`FULL`生成额外的数字。有关更多信息，请参阅 [ALTER TABLE-REPLICA IDENTITY](https://www.postgresql.org/docs/devel/sql-altertable.html)。 ## 只读副本作为 PostgreSQL 的源 使用 PostgreSQL 只读副本作为 CDC 源以减少主数据库 AWS DMS 的负载。此功能可从 PostgreSQL 16.x 中获得， AWS DMS 需要版本 3.6.1 或更高版本。使用只读副本进行 CDC 处理可以降低对主数据库的操作影响。 **注意** Amazon RDS PostgreSQL 版本 16.x 对三可用区（TAZ）配置中的只读副本逻辑复制有限制。要在 TAZ 部署中获得完整的只读副本逻辑复制支持，必须使用 PostgreSQL 版本 17.x 或更高版本。 ### 先决条件 在使用只读副本作为 CDC 源之前 AWS DMS，您必须在主数据库实例及其只读副本上启用逻辑复制，以便在只读副本上创建逻辑解码。执行以下操作： + 在主数据库实例及其只读副本以及所有其他必需的数据库参数上启用逻辑复制。有关更多信息，请参阅[使用 AWS托管的 PostgreSQL 数据库作为 DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.RDSPostgreSQL) 源。 + 对于仅限 CDC 的任务，请在主（写入器）实例上创建一个复制槽位。有关更多信息，请参阅[使用本机 CDC 开始点设置 PostgreSQL 源的 CDC 加载](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.v10)。此操作是必要的，因为只读副本不支持创建复制槽位。 + 对于 PostgreSQL 版本 16，必须在只读副本上手动创建槽位。 + 对于 PostgreSQL 版本 17 及更高版本，必须在主实例上创建复制槽位，并自动将其同步到只读副本。 + 使用 Full Load \$1 CDC 或仅限 CDC 的任务时， AWS DMS 可以自动管理主实例上的逻辑复制槽，但不能自动管理只读副本上的逻辑复制槽。对于 PostgreSQL 版本 16 只读副本，在重新启动任务（而不是恢复）之前，必须手动删除并重新创建复制槽位。跳过此步骤可能会导致任务失败或 CDC 起始位置不正确。从 PostgreSQL 版本 17 起，主实例的逻辑槽位同步将自动执行此过程。 完成先决条件后，您可以在终端节点设置中通过复制`SlotName`只读副本源来设置源终端节点，并使用本地 CDC 起点配置 AWS DMS 任务。 AWS DMS 有关更多信息，请参阅[使用 PostgreSQL 作为 DMS 源时的端点设置和额外连接属性 (ECAs) 和使用本地 CDC 起点设置 PostgreSQL](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.ConnectionAttrib) [源的 CDC 负载](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.v10)。 ## 使用 `MapBooleanAsBoolean` PostgreSQL 端点设置 您可以使用 PostgreSQL 端点设置将一个布尔值作为从 PostgreSQL 源映射到 Amazon Redshift 目标的布尔值。默认情况下，BOOLEAN 类型迁移为 varchar(5)。您可以指定 `MapBooleanAsBoolean` 让 PostgreSQL 将布尔类型迁移为布尔值，如以下示例所示。 ``` --postgre-sql-settings '{"MapBooleanAsBoolean": true}' ``` 请注意，您必须在源端点和目标端点上都设置此设置才能使其生效。 由于 MySQL 没有 BOOLEAN 类型，因此在将 BOOLEAN 数据迁移到 MySQL 时，请使用转换规则而不是此设置。 ## 使用 PostgreSQL 作为 DMS 源时的端点设置和额外连接属性 (ECAs) 您可以使用端点设置和额外的连接属性 (ECAs) 来配置您的 PostgreSQL 源数据库。在使用 AWS DMS 控制台创建源终端节点时，您可以指定终端节点设置，或者使用中带有 `--postgre-sql-settings '{"EndpointSetting": "value", ...}'` JSON 语法的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)命令来指定终端节点设置。 下表显示了端点设置以及 ECAs 您可以将 PostgreSQL 用作源的端点设置。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.PostgreSQL.html) ## 将 PostgreSQL 数据库作为 DMS 源的限制 将 PostgreSQL 作为 AWS DMS的源时，以下限制适用： + AWS DMS 不适用于亚马逊 RDS for PostgreSQL 10.4 或 Amazon Aurora PostgreSQL 10.4 作为源或目标。 + 捕获的表必须具有一个主键。如果表没有主键，则 AWS DMS 忽略该表的 DELETE 和 UPDATE 记录操作。有关解决方法，请参阅[使用逻辑复制启用更改数据捕获（CDC）](#CHAP_Source.PostgreSQL.Security)。 **注意：**我们不建议在没有主 Key/Unique 索引的情况下进行迁移，否则会有其他限制，例如 “否” Batch 应用功能、完整 LOB 功能、数据验证以及无法高效地复制到 Redshift 目标。 + AWS DMS 忽略更新主键段的尝试。在这些情况下，目标会将更新标识为未更新任何行的更新。但是，由于更新 PostgreSQL 中的主键的结果是不可预测的，不会将任何记录写入异常表。 + AWS DMS 不支持 “**从时间戳开始处理更改**” 运行选项。 + AWS DMS 不会复制因分区或子分区操作（`ADD``DROP`、或`TRUNCATE`）而产生的更改。 + 复制多个具有相同名称且每个名称大小写不同的表（例如 table1 和 Table1）可能会导致不可预测的行为。 TABLE1由于这个问题， AWS DMS 不支持这种类型的复制。 + 在大多数情况下， AWS DMS 支持对表的 CREATE、ALTER 和 DROP DDL 语句进行更改处理。 AWS DMS 如果表保存在内部函数或过程主体块或其他嵌套结构中，则不支持这种变更处理。 例如，不捕获以下更改。 ``` CREATE OR REPLACE FUNCTION attu.create_distributors1() RETURNS void LANGUAGE plpgsql AS $$ BEGIN create table attu.distributors1(did serial PRIMARY KEY,name varchar(40) NOT NULL); END; $$; ``` + 目前，PostgreSQL 源中的 `boolean` 数据类型会作为具有不一致值的 `bit` 数据类型迁移到 SQL Server 目标。解决方法是，使用列`VARCHAR(1)`的数据类型预先创建表（或者 AWS DMS 创建表）。然后，让下游处理将“F”视为 False，将“T”视为 True。 + AWS DMS 不支持 TRUNCATE 操作的更改处理。 + OID LOB 数据类型不会迁移到目标。 + AWS DMS 仅支持同构迁移的 PostGIS 数据类型。 + 如果您的源是本地或 Amazon EC2 实例上的 PostgreSQL 数据库，请确保将 test\$1decoding 输出插件安装到源端点上。您可以在 PostgreSQL contrib 包中找到此插件。有关测试解码插件的更多信息，请参阅 [PostgreSQL 文档](https://www.postgresql.org/docs/10/static/test-decoding.html)。 + AWS DMS 不支持更改处理以设置和取消设置列的默认值（在 ALTER TABLE 语句上使用 ALTER COLUMN SET DEFAULT 子句）。 + AWS DMS 不支持通过更改处理来设置列的空性（在 ALTER TABLE 语句上使用 ALTER COLUMN [SET\$1DROP] NOT NULL 子句）。 + 启用逻辑复制后，每个事务在内存中保留的最大更改数为 4MB。之后，更改会溢出到磁盘。因此，`ReplicationSlotDiskUsage` 会增加，并且在事务完成/停止并且回滚完成之前，`restart_lsn` 不会有进展。因为这是一个长时间运行的事务，可能需要花费较长时间回滚。因此，在启用逻辑复制时，请避免长时间运行的事务或许多子事务。请改为将事务分成几个较小的事务。 在 Aurora PostgreSQL 版本 13 及更高版本中，您可以调整 `logical_decoding_work_mem` 参数以控制 DMS 何时将更改数据溢出到磁盘。有关更多信息，请参阅 [Aurora PostgreSQL 中的溢出文件](CHAP_Troubleshooting_Latency_Source_PostgreSQL.md#CHAP_Troubleshooting_Latency_Source_PostgreSQL_Spill)。 + 数据类型为 ARRAY 的表必须具有主键。缺少主键的 ARRAY 数据类型的表在完全加载期间会暂停。 + AWS DMS 不支持迁移与表分区或表[继承相关的表](https://www.postgresql.org/docs/15/ddl-inherit.html)元数据。当 AWS DMS 遇到分区表或使用继承的表时，会观察到以下行为： + AWS DMS 标识并报告源数据库上分区或继承所涉及的父表和子表。 + **在目标数据库上创建表**：在目标数据库上，将表 AWS DMS 创建为标准（非分区、非继承）表，保留所选表的结构和属性，但不保留分区或继承逻辑。 + **继承表中的记录差异**：对于使用继承的表，在填充父表时 AWS DMS 不区分属于子表的记录。因此，它不使用带有诸如 `SELECT * FROM ONLY parent_table_name` 之类的语法的 SQL 查询。 + 要将分区表从 PostgreSQL 源复制到 PostgreSQL 目标，请先在目标上手动创建父表和子表。然后，定义单独的任务来向这些表进行复制。在这种情况下，请将任务配置设置为 **Truncate before loading**。 + PostgreSQL `NUMERIC` 数据类型不是固定大小。当传输的数据属于 `NUMERIC` 数据类型，但没有精度和小数位数时，默认情况下，DMS 使用 `NUMERIC(28,6)`（精度为 28，小数位数为 6）。例如，源中的值 0.611111104488373 在 PostgreSQL 目标中将转换为 0.611111。 + AWS DMS 仅支持 Aurora PostgreSQL Serverless V1 作为满载任务的来源。 AWS DMS 支持 Aurora PostgreSQL Serverless V2 作为满载、满载和 CDC 以及仅限 CDC 的任务的来源。 + AWS DMS 不支持复制使用合并函数创建的具有唯一索引的表。 + 如果源和目标上的主键定义不匹配，则复制的结果可能无法预测。 + 使用并行加载功能时，不支持根据分区或子分区对表进行分段。有关并行加载的更多信息，请参阅[对所选表、视图和集合使用并行加载](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)。 + AWS DMS 不支持延迟约束。 + AWS DMS 版本 3.4.7 支持 PostgreSQL 14.x 作为源代码，但有以下限制： + AWS DMS 不支持对两阶段提交的更改处理。 + AWS DMS 不支持逻辑复制以流式传输正在进行的长时间事务。 + AWS DMS 不支持 CDC for Amazon RDS Proxy for PostgreSQL 作为来源。 + 使用不包含主键列的[源过滤器](CHAP_Tasks.CustomizingTasks.Filters.md)时，不会捕获 `DELETE` 操作。 + 如果您的源数据库也是另一个第三方复制系统的目标，DDL 更改可能不会在 CDC 期间迁移。因为这种情况可能会防止触发 `awsdms_intercept_ddl` 事件触发器。要解决这种情况，请在源数据库上修改此触发器，如下所示： ``` alter event trigger awsdms_intercept_ddl enable always; ``` + AWS DMS 不支持复制对源数据库中主键定义所做的更改。如果在执行活动复制任务期间更改了主键结构，则随后对受影响表所做的更改不会复制到目标。 + 在作为脚本一部分的 DDL 复制中，每个脚本的 DDL 命令总数上限为 8192，每个脚本的总行数上限为 8192 行。 + AWS DMS 不支持实体化视图。 + 对于使用只读副本作为源的满载和 CDC 任务， AWS DMS 无法在只读副本上创建复制槽。 ## PostgreSQL 的源数据类型 下表显示了 AWS DMS 使用时支持的 PostgreSQL 源数据类型以及与数据类型的默认映射 AWS DMS 。 有关如何查看目标中映射的数据类型的信息，请参阅有关所使用的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | PostgreSQL 数据类型 | DMS 数据类型 | | --- | --- | | INTEGER | INT4 | | SMALLINT | INT2 | | BIGINT | INT8 | | NUMERIC (p,s) | 如果精度介于 0 和 38 之间，则使用 NUMERIC。 如果精度为 39 或更大的值，则使用 STRING。 | | DECIMAL(P,S) | 如果精度介于 0 和 38 之间，则使用 NUMERIC。 如果精度为 39 或更大的值，则使用 STRING。 | | REAL | REAL4 | | DOUBLE | REAL8 | | SMALLSERIAL | INT2 | | SERIAL | INT4 | | BIGSERIAL | INT8 | | MONEY | NUMERIC(38,4) MONEY 数据类型将映射到 SQL Server 中的 FLOAT。 | | CHAR | WSTRING (1) | | CHAR(N) | WSTRING (n) | | VARCHAR(N) | WSTRING (n) | | TEXT | NCLOB | | CITEXT | NCLOB | | BYTEA | BLOB | | TIMESTAMP | DATETIME | | TIMESTAMP（有时区） | DATETIME | | DATE | DATE | | TIME | TIME | | 带时区的时间 | TIME | | INTERVAL | STRING(128) – 1 YEAR、2 MONTHS、3 DAYS、4 HOURS、5 MINUTES、6 SECONDS | | BOOLEAN | CHAR (5) false 或 true | | ENUM | STRING (64) | | CIDR | STRING (50) | | INET | STRING (50) | | MACADDR | STRING (18) | | BIT (n) | STRING (n) | | BIT VARYING (n) | STRING (n) | | UUID | string | | TSVECTOR | CLOB | | TSQUERY | CLOB | | XML | CLOB | | POINT | STRING (255) "(x,y)" | | LINE | STRING (255) "(x,y,z)" | | LSEG | STRING (255) "((x1,y1),(x2,y2))" | | BOX | STRING (255) "((x1,y1),(x2,y2))" | | 路径 | CLOB "((x1,y1),(xn,yn))" | | POLYGON | CLOB "((x1,y1),(xn,yn))" | | CIRCLE | STRING (255) "(x,y),r" | | JSON | NCLOB | | JSONB | NCLOB | | ARRAY | NCLOB | | COMPOSITE | NCLOB | | HSTORE | NCLOB | | INT4射程 | STRING (255) | | INT8射程 | STRING (255) | | NUMRANGE | STRING (255) | | STRRANGE | STRING (255) | ### 使用 PostgreSQL 的 LOB 源数据类型 PostgreSQL 列大小将影响 PostgreSQL LOB 数据类型到 AWS DMS 数据类型的转换。为此，请对以下 AWS DMS 数据类型执行下列步骤： + BLOB – 在创建任务时，将 **LOB 大小限制为**设置为**最大 LOB 大小（KB）**值。 + CLOB — 复制将每个角色作为一个 UTF8 角色处理。因此，找到列中最长字符文本的长度，此处显示为 `max_num_chars_text`。使用此长度指定**将 LOB 大小限制为**的值。如果数据包含 4 字节字符，请乘以 2 以指定 **Limit LOB size to (将 LOB 大小限制为)** 值（以字节为单位）。在此示例中，**Limit LOB size to (将 LOB 大小限制为)** 等于 `max_num_chars_text` 乘以 2。 + NCLOB – 复制将每个字符作为双字节字符处理。因此，找到列中最长字符文本的长度（`max_num_chars_text`）并乘以 2。执行此操作来指定**将 LOB 大小限制为**的值。在此示例中，**Limit LOB size to (将 LOB 大小限制为)** 等于 `max_num_chars_text` 乘以 2。如果数据包含 4 字节字符，请再次乘以 2。在此示例中，**Limit LOB size to (将 LOB 大小限制为)** 等于 `max_num_chars_text` 乘以 4。 # 使用与 MySQL 兼容的数据库作为源 AWS DMS 你可以使用 Database Migration Service 从任何兼容 MySQL 的数据库（MySQL、MariaDB 或 Amazon Aurora MySQL）迁移数据。 AWS 有关 AWS DMS 支持作为源的 MySQL 版本的信息，请参阅[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 您可以使用 SSL 来加密 MySQL 兼容终端节点与复制实例之间的连接。有关将 SSL 用于 MySQL 兼容终端节点的更多信息，请参阅[将 SSL 与 AWS Database Migration Service](CHAP_Security.SSL.md)。 在以下各节中，术语“自管理”适用于在本地安装或在 Amazon EC2 上安装的任何数据库。术语“AWS托管”适用于 Amazon RDS、Amazon Aurora 或 Amazon S3 上的任何数据库。 有关使用与 MySQL 兼容的数据库和的更多详细信息 AWS DMS，请参阅以下章节。 **Topics** + [使用从 MySQL 迁移到 MySQL AWS DMS](#CHAP_Source.MySQL.Homogeneous) + [使用任何与 MySQL 兼容的数据库作为源 AWS DMS](#CHAP_Source.MySQL.Prerequisites) + [使用自管理的 MySQL 兼容数据库作为源 AWS DMS](#CHAP_Source.MySQL.CustomerManaged) + [使用 AWS托管的 MySQL 兼容数据库作为源 AWS DMS](#CHAP_Source.MySQL.AmazonManaged) + [使用 MySQL 数据库作为源代码的限制 AWS DMS](#CHAP_Source.MySQL.Limitations) + [支持 XA 事务](#CHAP_Source.MySQL.XA) + [使用 MySQL 作为来源时的端点设置 AWS DMS](#CHAP_Source.MySQL.ConnectionAttrib) + [MySQL 的源数据类型](#CHAP_Source.MySQL.DataTypes) **注意** 配置 AWS Database Migration Service (AWS DMS) 映射规则时，请务必避免对数据库或架构名称使用通配符 (%)。相反，您必须仅明确指定需要进行迁移的用户创建数据库。使用通配符包括迁移过程中的所有数据库，包括目标实例上不需要的系统数据库。由于 MySQL Amazon RDS 主用户缺乏将数据导入目标系统数据库的必要权限，因此尝试迁移这些系统数据库会失败。 ## 使用从 MySQL 迁移到 MySQL AWS DMS 对于异构迁移，从MySQL以外的数据库引擎迁移到MySQL数据库，几乎 AWS DMS 总是最好的迁移工具。但是，对于同构迁移，即从 MySQL 数据库迁移到 MySQL 数据库，我们建议您使用同构数据迁移项目。与 AWS DMS相比，同构数据迁移使用原生数据库工具来提供更好的数据迁移性能和准确性。 ## 使用任何与 MySQL 兼容的数据库作为源 AWS DMS 在开始使用 MySQL 数据库作为源之前 AWS DMS，请确保满足以下先决条件。这些先决条件适用于自行管理或由管理的 AWS来源。 您必须拥有一个 AWS DMS 具有复制管理员角色的帐户。该角色需要以下权限： + **REPLICATION CLIENT** – 仅 CDC 任务需要此权限。换句话说， full-load-only任务不需要此权限。 **注意** 对于 MariaDB 版本 10.5.2\$1，你可以使用 BINLOG MONITOR，它是复制客户端的替代品。 + **REPLICATION SLAVE** – 仅 CDC 任务需要此权限。换句话说， full-load-only任务不需要此权限。 + **SUPER** - 仅 MySQL 5.6.6 之前的版本需要此权限。 AWS DMS 用户还必须对指定用于复制的源表具有 SELECT 权限。 如果您使用特定于 MySQL 的预迁移评估，请授予以下权限： ``` grant select on mysql.user to ; grant select on mysql.db to ; grant select on mysql.tables_priv to ; grant select on mysql.role_edges to #only for MySQL version 8.0.11 and higher grant select on performance_schema.replication_connection_status to ; #Required for primary instance validation - MySQL version 5.7 and higher only ``` 如果您使用的是 RDS 源并计划运行特定于 MySQL 的预迁移评估，请添加以下权限： ``` grant select on mysql.rds_configuration to ; #Required for binary log retention check ``` 如果参数 `BatchEnable` 为 `true`，则需要授予： ``` grant create temporary tables on ``.* to ; ``` ## 使用自管理的 MySQL 兼容数据库作为源 AWS DMS 您可以使用以下与 MySQL 兼容的自管理数据库作为 AWS DMS的源： + MySQL Community Edition + MySQL Standard Edition + MySQL Enterprise Edition + MySQL Cluster Carrier Grade Edition + MariaDB Community Edition + MariaDB Enterprise Edition + MariaDB Column Store 要使用 CDC，请确保启用二进制日志记录。要启用二进制日志记录，则必须在 MySQL 的 `my.ini` (Windows) 或 `my.cnf` (UNIX) 文件中配置以下参数。 | 参数 | 值 | | --- | --- | | `server_id` | 将该参数设置为 1 或更大的值。 | | `log-bin` | 设置二进制日志文件的路径，例如 `log-bin=E:\MySql_Logs\BinLog`。请勿包含文件扩展名。 | | `binlog_format` | 将该参数设置为 `ROW`。我们建议在复制期间使用此设置，因为在某些情况下，如果 `binlog_format` 设置为 `STATEMENT`，那么在将数据复制到目标时可能会导致不一致。如果 `binlog_format` 设置为 `MIXED`，数据库引擎还会向目标写入类似的不一致数据，因为数据库引擎会自动切换到基于 `STATEMENT` 的日志记录，这可能导致在目标数据库上写入不一致的数据。 | | `expire_logs_days` | 将该参数设置为 1 或更大的值。为防止过度使用磁盘空间，我们建议您不要使用默认值 0。 | | `binlog_checksum` | 对于 DMS 版本 3.4.7 或之前的版本，请将此参数设置为 `NONE`。 | | `binlog_row_image` | 将该参数设置为 `FULL`。 | | `log_slave_updates` | 如果您使用 MySQL 或 MariaDB 只读副本作为源，请将此参数设置为 `TRUE`。 | 如果您使用 MySQL 或 MariaDB 只读副本作为 DMS 迁移任务的源，并使用**迁移现有数据并复制持续更改**模式，则可能会丢失数据。在以下情况下，无论是在完全加载期间还是 CDC 期间，DMS 都不会写入事务： + 在 DMS 任务开始之前，事务已提交到主实例。 + 由于主实例和副本之间存在延迟，直到 DMS 任务开始后，事务才提交到副本。 主实例和副本之间的延迟时间越长，数据丢失的可能性就越大。 如果您的源使用了 NDB（集群式）数据库引擎，则必须配置以下参数以对使用该存储引擎的表启用 CDC。请在 MySQL 的 `my.ini` (Windows) 或 `my.cnf` (UNIX) 文件中添加这些更改。 | 参数 | 值 | | --- | --- | | `ndb_log_bin` | 将该参数设置为 `ON`。此值确保在集群表中进行的更改保存到二进制日志。 | | `ndb_log_update_as_write` | 将该参数设置为 `OFF`。此值可以防止将 UPDATE 语句作为 INSERT 语句写入二进制日志。 | | `ndb_log_updated_only` | 将该参数设置为 `OFF`。此值可确保二进制日志包含整个行而不仅仅是更改的列。 | ## 使用 AWS托管的 MySQL 兼容数据库作为源 AWS DMS 您可以使用以下 AWS托管的 MySQL 兼容数据库作为源： AWS DMS + MySQL Community Edition + MariaDB Community Edition + Amazon Aurora MySQL 兼容版 使用与 AWS托管的 MySQL 兼容数据库作为源时 AWS DMS，请确保您满足以下使用 CDC 的先决条件： + 要为 RDS for MySQL 和 RDS for MariaDB 启用二进制日志，请在实例级别启用自动备份。要为 Aurora MySQL 集群启用二进制日志，请更改参数组中的变量 `binlog_format`。 有关设置自动备份的更多信息，请参阅《Amazon RDS 用户指南》中的[使用自动备份](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html)**。 有关为 Amazon RDS for MySQL 数据库设置二进制日志记录的更多信息，请参阅《Amazon RDS 用户指南》中的[设置二进制日志记录格式](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.MySQL.BinaryFormat.html)**。 有关为 Aurora MySQL 集群设置二进制日志记录的更多信息，请参阅[如何为 Amazon Aurora MySQL 集群开启二进制日志记录？](https://aws.amazon.com/premiumsupport/knowledge-center/enable-binary-logging-aurora/)。 + 如果您计划使用 CDC，请启用二进制日志记录。有关为 Amazon RDS for MySQL 数据库设置二进制日志记录的更多信息，请参阅《Amazon RDS 用户指南》中的[设置二进制日志记录格式](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.MySQL.BinaryFormat.html)**。 + 确保二进制日志可供使用 AWS DMS。由于与 AWS MySQL 兼容的数据库会尽快清除二进制日志，因此您应该延长日志的可用时间。例如，要将日志保留时间延长至 24 小时，请运行以下命令。 ``` call mysql.rds_set_configuration('binlog retention hours', 24); ``` + 将 `binlog_format` 参数设置为 `"ROW"`。 **注意** 在 MySQL 或 MariaDB 上，`binlog_format` 是一个动态参数，因此您不必重新启动即可使新值生效。但是，新值仅适用于新会话。如果您出于复制目的将 `binlog_format` 切换为 `ROW`，则如果这些会话在您更改值之前已启动，则数据库仍可以使用 `MIXED` 格式创建后续的二进制日志。这可能会 AWS DMS 阻止正确捕获源数据库上的所有更改。更改 MariaDB 或 MySQL 数据库的 `binlog_format` 设置时，请务必重新启动数据库以关闭所有现有会话，或者重新启动任何执行 DML（Data Manipulation Language，数据操作语言）操作的应用程序。将`binlog_format`参数更改为后强制数据库重新启动所有会话`ROW`将确保您的数据库使用正确的格式写入所有后续的源数据库更改，以便 AWS DMS 可以正确捕获这些更改。 + 将 `binlog_row_image` 参数设置为 `"Full"`。 + 对于 DMS 版本 3.4.7 或之前的版本，请将 `binlog_checksum` 参数设置为 `"NONE"`。有关在 Amazon RDS MySQL 中设置参数的更多信息，请参阅《Amazon RDS 用户指南》中的[使用自动备份](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html)**。 + 如果您使用 Amazon RDS MySQL 或 Amazon RDS MariaDB 只读副本作为源，请在只读副本上启用备份，并确保 `log_slave_updates` 参数设置为 `TRUE`。 ## 使用 MySQL 数据库作为源代码的限制 AWS DMS 使用 MySQL 数据库作为源时，请考虑以下事项： + Amazon RDS MySQL 5.5 或更低版本不支持更改数据捕获（CDC）。对于 Amazon RDS MySQL，您必须使用版本 5.6、5.7 或 8.0 才能启用 CDC。自管理 MySQL 5.5 源支持 CDC。 + 对于 CDC，`CREATE TABLE`、`ADD COLUMN` 和 `DROP COLUMN` 更改列数据类型，并支持 `renaming a column`。但是，不支持 `DROP TABLE`、`RENAME TABLE` 和对其他属性（例如列默认值、列可为 null 值、字符集等）进行更新。 + 对于源上的分区表，当您将**目标表准备模式设置为 “在目标****上删除表**” 时，将 AWS DMS 创建一个在 MySQL 目标上没有任何分区的简单表。要将分区表迁移到目标上的分区表，请预先在目标 MySQL 数据库创建分区表。 + 关系目标不支持使用`ALTER TABLE table_name ADD COLUMN column_name`语句将列添加到表的开头 (FIRST) 或中间 (AFTER)。列始终添加到表的末尾。当目标是 Amazon S3 或 Amazon Kinesis Data Streams 时，支持使用 FIRST 或 AFTER 添加列。 + 当表名称包含大写和小写字符且源引擎托管于包含不区分大小写的文件名的操作系统上时，CDC 不受支持。一个示例是使用 HFS\$1 的 Microsoft Windows 或 OS X。 + 您可以使用 Aurora MySQL 兼容版 Serverless v1 进行完全加载，但不能将其用于 CDC。这是因为您无法为 MySQL 启用先决条件。有关更多信息，请参阅[参数组和 Aurora Serverless v1](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.how-it-works.html#aurora-serverless.parameter-groups)。 Aurora MySQL 兼容版 Serverless v2 支持 CDC。 + 列上的 AUTO\$1INCREMENT 属性不会迁移到目标数据库列。 + 当二进制日志未存储在标准块存储上时，不支持捕获更改。例如，当二进制日志存储在 Amazon S3 中时，CDC 不起作用。 + AWS DMS 默认使用InnoDB存储引擎创建目标表。如果您需要使用 InnoDB 之外的存储引擎，则必须手动创建该表并使用 [Do nothing (不执行任何操作)](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_GettingStarted.html) 模式迁移到该表。 + 除非您的 DMS 迁移任务模式为 “迁移**现有数据** — 仅限满载”， AWS DMS 否则您不能使用 Aurora MySQL 副本作为源。 + 如果与 MySQL 兼容的源在完全加载期间停止， AWS DMS 任务不会停止，但会出现错误。该任务将成功结束，但目标可能与源不同步。如果发生这种情况，请重新启动该任务或重新加载受影响的表。 + 在列值的一部分上创建的索引不会迁移。例如，索引 CREATE INDEX first\$1ten\$1chars ON customer (名称 (10)) 不在目标上创建。 + 在某些情况下，任务被配置为不复制 LOBs（任务设置中的 SupportLobs “” 为 false 或者在任务控制台中选择了 “**不包含 LOB” 列**）。在这些情况下， AWS DMS 不会将任何 MEDIUMBLOB、LONGBLOB、MEDIUMTEXT 和 LONGTEXT 列迁移到目标。 BLOB、TINYBLOB、TEXT 和 TINYTEXT 列不会受到影响且将迁移到目标。 + MariaDB 源数据库和目标数据库不支持临时数据表或系统版本控制表。 + 如果在两个 Amazon RDS Aurora MySQL 集群之间迁移，则 RDS Aurora MySQL 源终端节点必须是 read/write 实例，而不是副本实例。 + AWS DMS 目前不支持 MariaDB 的视图迁移。 + AWS DMS 不支持 MySQL 分区表的 DDL 更改。要跳过 CDC 期间因分区 DDL 更改而暂停表的情况，请将 `skipTableSuspensionForPartitionDdl` 设置为 `true`。 + AWS DMS 仅支持 3.5.0 及更高版本中的 XA 事务。以前的版本不支持 XA 事务。 AWS DMS 在 MariaDB 10.6 或更高版本中不支持 XA 事务。有关更多信息，请参阅以下内容。[支持 XA 事务](#CHAP_Source.MySQL.XA) + AWS DMS 不 GTIDs 用于复制，即使源数据包含复制。 + AWS DMS 不支持 Aurora MySQL 增强型二进制日志。 + AWS DMS 不支持二进制日志事务压缩。 + AWS DMS 不会在使用 InnoDB 存储引擎的 MySQL 数据库的 “删除级联” 和 “更新时级联” 事件进行传播。对于这些事件，MySQL 不会生成二进制日志事件来反映子表上的级联操作。因此， AWS DMS 无法将相应的更改复制到子表。有关更多信息，请参阅 [索引、外键或级联更新内容或删除内容未迁移](CHAP_Troubleshooting.md#CHAP_Troubleshooting.MySQL.FKsAndIndexes)。 + AWS DMS 不捕获对计算（`VIRTUAL`和`GENERATED ALWAYS`）列的更改。要解决此限制，请执行以下操作之一： + 在目标数据库中预先创建目标表，然后使用 `DO_NOTHING` 或 `TRUNCATE_BEFORE_LOAD` 完全加载任务设置创建 AWS DMS 任务。 + 添加转换规则以从任务范围中移除计算列。有关转换规则的信息，请参阅[转换规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。 + 由于 MySQL 的内部限制， AWS DMS 可以处理 BINLOGs 不超过 4GB 的大小。 BINLOGs 大于 4GB 可能会导致 DMS 任务失败或其他不可预测的行为。您必须减小交易大小以避免 BINLOGs 超过 4GB。 + AWS DMS 不支持架构、表和列名中的反引号 (````'`) 或单引号 ()。 + AWS DMS 不会迁移源数据库中不可见列的数据。要将这些列纳入迁移范围内，请使用 ALTER TABLE 语句使这些列可见。 ## 支持 XA 事务 扩展架构（XA）事务用于将来自多个事务资源的一系列操作，分组为单个可靠的全局事务。XA 事务使用两阶段提交协议。通常，在有未处理的 XA 事务时捕获更改可能会导致数据丢失。如果您的数据库不使用 XA 事务，则可以使用默认值 `TRUE` 忽略此权限和配置 `IgnoreOpenXaTransactionsCheck`。要开始从具有 XA 事务的源进行复制，请执行以下操作： + 确保终 AWS DMS 端用户具有以下权限： ``` grant XA_RECOVER_ADMIN on *.* to 'userName'@'%'; ``` + 将端点设置 `IgnoreOpenXaTransactionsCheck` 设置为 `false`。 **注意** AWS DMS 不支持 MariaDB 源数据库 10.6 或更高版本上的 XA 事务。 ## 使用 MySQL 作为来源时的端点设置 AWS DMS 您可以使用端点设置来配置 MySQL 源数据库，这与使用额外连接属性类似。您可以在使用 AWS DMS 控制台创建源端点时指定设置，或者使用中带有 `--my-sql-settings '{"EndpointSetting": "value", ...}'` JSON 语法的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)命令来指定设置。 下表显示了将 MySQL 用作源时您可以使用的端点设置。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.MySQL.html) ## MySQL 的源数据类型 下表显示了使用时支持的 MySQL 数据库源数据类型 AWS DMS 以及 AWS DMS 数据类型的默认映射。 有关如何查看目标中映射的数据类型的信息，请参阅有关所使用的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | MySQL 数据类型 | AWS DMS 数据类型 | | --- | --- | | INT | INT4 | | BIGINT | INT8 | | MEDIUMINT | INT4 | | TINYINT | INT1 | | SMALLINT | INT2 | | UNSIGNED TINYINT | UINT1 | | UNSIGNED SMALLINT | UINT2 | | UNSIGNED MEDIUMINT | UINT4 | | UNSIGNED INT | UINT4 | | UNSIGNED BIGINT | UINT8 | | DECIMAL(10) | NUMERIC (10,0) | | BINARY | BYTES(1) | | BIT | BOOLEAN | | BIT(64) | BYTES(8) | | BLOB | BYTES(65535) | | LONGBLOB | BLOB | | MEDIUMBLOB | BLOB | | TINYBLOB | BYTES(255) | | DATE | DATE | | DATETIME | DATETIME 不带括号值的 DATETIME 复制时不包括毫秒。括号值为 1 到 5 的 DATETIME（例如 `DATETIME(5)`）在复制时包括毫秒。 复制 DATETIME 列时，时间在目标上保持不变。它不会转换为 UTC。 | | TIME | string | | TIMESTAMP | DATETIME 复制 TIMESTAMP 列时，目标上的时间会转换为 UTC。 | | YEAR | INT2 | | DOUBLE | REAL8 | | FLOAT | REAL(DOUBLE) 如果 FLOAT 值不在以下范围内，请使用转换将 FLOAT 映射到 STRING。有关转换的更多信息，请参阅 [转换规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。 支持的 FLOAT 范围是 -1.79E\$1308 到 -2.23E-308、0 以及 2.23E-308 到 1.79E\$1308 | | VARCHAR(45) | WSTRING (45) | | VARCHAR(2000) | WSTRING (2000) | | VARCHAR(4000) | WSTRING (4000) | | VARBINARY (4000) | BYTES (4000) | | VARBINARY (2000) | BYTES (2000) | | CHAR | WSTRING | | TEXT | WSTRING | | LONGTEXT | NCLOB | | MEDIUMTEXT | NCLOB | | TINYTEXT | WSTRING(255) | | GEOMETRY | BLOB | | POINT | BLOB | | LINESTRING | BLOB | | POLYGON | BLOB | | MULTIPOINT | BLOB | | MULTILINESTRING | BLOB | | MULTIPOLYGON | BLOB | | GEOMETRYCOLLECTION | BLOB | | ENUM | WSTRING () *length* 这*length*是 ENUM 中最长值的长度。 | | SET | WSTRING () *length* 这里*length*是 SET 中所有值的总长度，包括逗号。 | | JSON | CLOB | **注意** 在某些情况下，您可以使用“零”值（即 0000-00-00）来指定 DATETIME 和 TIMESTAMP 数据类型。如果这样做，请确保复制任务中的目标数据库支持 DATETIME 和 TIMESTAMP 数据类型的“零”值。否则，这些值在目标上将被记录为 null。 # 使用 SAP ASE 数据库作为来源 AWS DMS 您可以使用从 SAP Adaptive Server Enterprise (ASE) 数据库（以前称为 Sybase）迁移数据。 AWS DMS使用 SAP ASE 数据库作为源，您可以将数据迁移到任何其他支持的 AWS DMS 目标数据库。 有关 AWS DMS 支持作为源的 SAP ASE 版本的信息，请参阅[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 有关使用 SAP ASE 数据库和的更多详细信息 AWS DMS，请参阅以下各节。 **Topics** + [使用 SAP ASE 数据库作为源的先决条件 AWS DMS](#CHAP_Source.SAP.Prerequisites) + [使用 SAP ASE 作为来源的限制 AWS DMS](#CHAP_Source.SAP.Limitations) + [使用 SAP ASE 作为来源所需的权限 AWS DMS](#CHAP_Source.SAP.Security) + [删除截断点](#CHAP_Source.SAP.Truncation) + [使用 SAP ASE 作为来源时的端点设置 AWS DMS](#CHAP_Source.SAP.ConnectionAttrib) + [SAP ASE 的源数据类型](#CHAP_Source.SAP.DataTypes) ## 使用 SAP ASE 数据库作为源的先决条件 AWS DMS 要将 SAP ASE 数据库作为其来源 AWS DMS，请执行以下操作： + 使用 `sp_setreptable` 命令为表启用 SAP ASE 复制。有关更多信息，请参阅 [Sybase Infocenter 存档]( http://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.dc32410_1501/html/refman/X37830.htm)。 + 在 SAP ASE 数据库上禁用 `RepAgent`。有关更多信息，请参阅[停止和禁用主数据库中的 RepAgent 线程](http://infocenter-archive.sybase.com/help/index.jsp?topic=/com.sybase.dc20096_1260/html/mra126ag/mra126ag65.htm)。 + 要在配置为非拉丁字符（例如中文）的 Windows EC2 实例上复制到 SAP ASE 15.7 版，请在目标计算机 SP121上安装 SAP ASE 15.7。 **注意** 对于持续的更改数据捕获（CDC）复制，DMS 会运行 `dbcc logtransfer` 和 `dbcc log`，以从事务日志中读取数据。 ## 使用 SAP ASE 作为来源的限制 AWS DMS 将 SAP ASE 数据库作为 AWS DMS源时，存在以下限制： + 对于每个 SAP ASE 数据库，您只能使用持续复制或 CDC 运行 AWS DMS 一项任务。您可以并行运行多个 full-load-only任务。 + 您不能重命名表。例如，下面的命令将失败。 ``` sp_rename 'Sales.SalesRegion', 'SalesReg; ``` + 您不能重命名列。例如，下面的命令将失败。 ``` sp_rename 'Sales.Sales.Region', 'RegID', 'COLUMN'; ``` + 在复制到目标数据库时，将截断位于二进制数据类型字符串末尾的零值。例如，源表中的 `0x0000000000000000000000000100000100000000` 在目标表中变为 `0x00000000000000000000000001000001`。 + 如果将数据库默认值设置为不允许 NULL 值，则使用不允许 NULL 值的列 AWS DMS 创建目标表。因此，如果满载或 CDC 复制任务包含空值，则 AWS DMS 会引发错误。您可以执行以下命令以允许在源数据库中包含 NULL 值，从而防止出现这些错误。 ``` sp_dboption database_name, 'allow nulls by default', 'true' go use database_name CHECKPOINT go ``` + 不支持 `reorg rebuild` 索引命令。 + AWS DMS 不支持群集或使用 MSA（多站点可用性）/热备用作为源。 + 在映射规则中使用 `AR_H_TIMESTAMP` 转换标头表达式时，不会捕获已添加列的毫秒数。 + 在 CDC 期间运行合并操作将导致不可恢复的错误。要使目标恢复同步，请运行完全加载。 + 使用数据行锁定方案的表不支持回滚触发器事件。 + AWS DMS 从源 SAP 数据库中删除任务范围内的表后，无法恢复复制任务。如果 DMS 复制任务已停止并执行了任何 DML 操作（INSERT、UPDATE、DELETE），然后删除了表，则必须重新启动复制任务。 ## 使用 SAP ASE 作为来源所需的权限 AWS DMS 要在 AWS DMS 任务中使用 SAP ASE 数据库作为源，您需要授予权限。向 AWS DMS 数据库定义中指定的用户帐户授予在 SAP ASE 数据库中的以下权限： + sa\$1role + replication\$1role + sybase\$1ts\$1role + 默认情况下，如果需要拥有运行`sp_setreptable`存储过程的权限，则 AWS DMS 启用 SAP ASE 复制选项。如果要直接从数据库端点而不是通过其 AWS DMS 自身在表`sp_setreptable`上运行，则可以使用 e `enableReplication` xtra 连接属性。有关更多信息，请参阅 [使用 SAP ASE 作为来源时的端点设置 AWS DMS](#CHAP_Source.SAP.ConnectionAttrib)。 ## 删除截断点 任务启动时，会在`syslogshold`系统视图中 AWS DMS 建立一个`$replication_truncation_point`条目，表示复制过程正在进行中。 AWS DMS 在工作时，它会根据已经复制到目标的数据量定期推进复制截断点。 建立条`$replication_truncation_point`目后，请保持 AWS DMS 任务运行以防止数据库日志变得过大。如果要永久停止 AWS DMS 任务，请发出以下命令来移除复制截断点： ``` dbcc settrunc('ltm','ignore') ``` 删除截断点后，您将无法继续执行任务。 AWS DMS 日志将继续在检查点自动截断 (在设置了自动截断时)。 ## 使用 SAP ASE 作为来源时的端点设置 AWS DMS 您可以使用端点设置来配置 SAP ASE 源数据库，这与使用额外连接属性类似。您可以在使用 AWS DMS 控制台创建源端点时指定设置，或者使用中带有 `--sybase-settings '{"EndpointSetting": "value", ...}'` JSON 语法的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)命令来指定设置。 下表显示了将 SAP ASE 用作源时您可以使用的端点设置。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.SAP.html) ## SAP ASE 的源数据类型 有关使用时支持的 SAP ASE 源数据类型列表 AWS DMS 以及 AWS DMS 数据类型的默认映射，请参阅下表。 AWS DMS 不支持包含用户定义类型 (UDT) 数据类型列的 SAP ASE 源表。具有此数据类型的复制列将创建为 NULL。 有关如何查看目标中映射的数据类型的信息，请参阅[数据迁移的目标](CHAP_Target.md)有关您的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | SAP ASE 数据类型 | AWS DMS 数据类型 | | --- | --- | | BIGINT | INT8 | | UNSIGNED BIGINT | UINT8 | | INT | INT4 | | UNSIGNED INT | UINT4 | | SMALLINT | INT2 | | UNSIGNED SMALLINT | UINT2 | | TINYINT | UINT1 | | DECIMAL | NUMERIC | | NUMERIC | NUMERIC | | FLOAT | REAL8 | | DOUBLE | REAL8 | | REAL | REAL4 | | MONEY | NUMERIC | | SMALLMONEY | NUMERIC | | DATETIME | DATETIME | | BIGDATETIME | DATETIME(6) | | SMALLDATETIME | DATETIME | | DATE | DATE | | TIME | TIME | | BIGTIME | TIME | | CHAR | string | | UNICHAR | WSTRING | | NCHAR | WSTRING | | VARCHAR | string | | UNIVARCHAR | WSTRING | | NVARCHAR | WSTRING | | BINARY | BYTES | | VARBINARY | BYTES | | BIT | BOOLEAN | | TEXT | CLOB | | UNITEXT | NCLOB | | IMAGE | BLOB | # 使用 MongoDB 作为来源 AWS DMS 有关支持作为源的 MongoDB 版本的信息 AWS DMS ，请参阅。[的来源 AWS DMS](CHAP_Introduction.Sources.md) 请注意以下有关 MongoDB 版本支持的信息： + AWS DMS 3.4.5 及更高版本支持 MongoDB 版本 4.2 和 4.4。 + AWS DMS 3.4.5 及更高版本以及 MongoDB 4.2 及更高版本支持分布式事务。有关 MongoDB 分布式事务的更多信息，请参阅 [MongoDB 文档](https://www.mongodb.com/docs/)中的[事务](https://docs.mongodb.com/manual/core/transactions/)。 + AWS DMS 3.5.0 及更高版本不支持 3.6 之前的 MongoDB 版本。 + AWS DMS 3.5.1 及更高版本支持 MongoDB 版本 5.0。 + AWS DMS 3.5.2 及更高版本支持 MongoDB 版本 6.0。 + AWS DMS 3.5.4 及更高版本支持 MongoDB 版本 7.0 和 8.0。 如果您是初次使用 MongoDB，请注意以下关于 MongoDB 数据库的重要概念： + MongoDB 中的记录是一个*文档*，它是由字段和值对构成的数据结构。字段值可以包含其他文档、数组和文档数组。文档大致相当于关系数据库表中的行。 + MongoDB 中的*集合* 是一组文档，并且大致相当于关系数据库表。 + MongoDB 中的*数据库*是一组集合，并且大致相当于关系数据库中的架构。 + 在内部，MongoDB 文档以压缩格式存储为二进制 JSON (BSON) 文件，包含文档中每个字段的类型。每个文档都有唯一的 ID。 AWS DMS *使用 MongoDB 作为源代码时支持两种迁移模式：*文档模式或表格*模式。*您可以在创建 MongoDB 端点时指定要使用的迁移模式，或者通过从 AWS DMS 控制台设置**元数据模式**参数来指定。或者，您可以创建名为 `_id` 的第二列，通过在端点配置面板中选中**将 \$1id 作为单独的列**复选标记，将其作为主键。 您选择的迁移模式将影响目标数据的结果格式，如下所述。 **文档模式** 在文档模式下，MongoDB 文档按“原样”迁移，这意味着文档数据将并入目标表中一个名为 `_doc` 的列中。文档模式是您将 MongoDB 作为源终端节点时的默认设置。 例如，请考虑名为 myCollection 的 MongoDB 集合中的以下文档。 ``` db.myCollection.find() { "_id" : ObjectId("5a94815f40bd44d1b02bdfe0"), "a" : 1, "b" : 2, "c" : 3 } { "_id" : ObjectId("5a94815f40bd44d1b02bdfe1"), "a" : 4, "b" : 5, "c" : 6 } ``` 在使用文档模式将数据迁移到关系数据库表后，数据结构如下所示。MongoDB 文档中的数据字段将并入` _doc` 列。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.MongoDB.html) 您可以选择将额外连接属性 `extractDocID` 设置为 *true*，以创建第二个名为 `"_id"` 的列作为主键。如果要使用 CDC，请将此参数设置为 *true*。 对生成[多文档交易](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction)的来源使用 CDC 时，**必须将**该`ExtractDocId`参数设置为 *true*。如果未启用此参数，则 AWS DMS 任务在遇到多文档事务时将失败。 在文档模式下， AWS DMS 管理集合的创建和重命名，如下所示： + 如果向源数据库添加新集合，则会为该集合 AWS DMS 创建一个新的目标表并复制所有文档。 + 如果您重命名源数据库上的现有集合， AWS DMS 不会重命名目标表。 如果目标端点是 Amazon DocumentDB，请在**文档模式**下运行迁移。 **表模式** 在表格模式下， AWS DMS 将 MongoDB 文档中的每个顶级字段转换为目标表中的一列。如果字段是嵌套的，则将嵌套值 AWS DMS 展平为一列。 AWS DMS 然后将关键字段和数据类型添加到目标表的列集中。 对于每个 MongoDB 文档 AWS DMS ，将每个键和类型添加到目标表的列集中。例如，使用表格模式，将前面的示例 AWS DMS 迁移到下表中。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.MongoDB.html) 嵌套值平展到包含键名 (以句点分隔) 的列中。该列的名称是为由句点分隔的平展字段名的联接。例如， AWS DMS 将包含嵌套值字段（例如嵌套值）的 JSON 文档迁移`{"a" : {"b" : {"c": 1}}}`到名为的列中 `a.b.c.` 要创建目标列，请 AWS DMS 扫描指定数量的 MongoDB 文档，然后创建一组包含所有字段及其类型。 AWS DMS 然后使用此集合来创建目标表的列。如果您使用 控制台创建或修改 MongoDB 源终端节点，则可指定要扫描的文档的数量。默认值为 1000 个文档。如果使用 AWS CLI，则可以使用额外的连接属性`docsToInvestigate`。 在表格模式下，像这样 AWS DMS 管理文档和集合： + 当您将一个文档添加到现有集合时，将复制该文档。如果某些字段在目标中不存在，则不会复制这些字段。 + 当您更新文档时，复制更新后的文档。如果某些字段在目标中不存在，则不会复制这些字段。 + 完全支持文档删除。 + 在 CDC 任务期间，添加新集合不会导致在目标上生成新的表。 + 在更改数据捕获 (CDC) 阶段， AWS DMS 不支持重命名集合。 **Topics** + [使用 MongoDB 作为源时所需的权限 AWS DMS](#CHAP_Source.MongoDB.PrerequisitesCDC) + [为 CDC 配置 MongoDB 副本集](#CHAP_Source.MongoDB.PrerequisitesCDC.ReplicaSet) + [使用 MongoDB 作为源时的安全要求 AWS DMS](#CHAP_Source.MongoDB.Security) + [对 MongoDB 集合进行分段并以并行方式迁移](#CHAP_Source.MongoDB.ParallelLoad) + [使用 MongoDB 作为源时迁移多个数据库 AWS DMS](#CHAP_Source.MongoDB.Multidatabase) + [使用 MongoDB 作为源代码时的限制 AWS DMS](#CHAP_Source.MongoDB.Limitations) + [使用 MongoDB 作为源时的端点配置设置 AWS DMS](#CHAP_Source.MongoDB.Configuration) + [MongoDB 的源数据类型](#CHAP_Source.MongoDB.DataTypes) ## 使用 MongoDB 作为源时所需的权限 AWS DMS 对于使用 MongoDB 源进行 AWS DMS 迁移，您可以创建一个具有 root 权限的用户帐户，也可以创建仅具有要迁移的数据库权限的用户。 以下代码创建将作为根账户的用户。 ``` use admin db.createUser( { user: "root", pwd: "password", roles: [ { role: "root", db: "admin" } ] } ) ``` 对于 MongoDB 3.x 源，以下代码在要迁移的数据库上创建具有最低权限的用户。 ``` use database_to_migrate db.createUser( { user: "dms-user", pwd: "password", roles: [ { role: "read", db: "local" }, "read"] }) ``` 对于 MongoDB 4.x 源，以下代码创建具有最低权限的用户。 ``` { resource: { db: "", collection: "" }, actions: [ "find", "changeStream" ] } ``` 例如，在“admin”数据库中创建以下角色。 ``` use admin db.createRole( { role: "changestreamrole", privileges: [ { resource: { db: "", collection: "" }, actions: [ "find","changeStream" ] } ], roles: [] } ) ``` 创建角色后，在要迁移的数据库中创建用户。 ``` use test > db.createUser( { user: "dms-user12345", pwd: "password", roles: [ { role: "changestreamrole", db: "admin" }, "read"] }) ``` ## 为 CDC 配置 MongoDB 副本集 要将持续复制或 CDC 与 MongoDB 配合使用 AWS DMS ，需要访问 MongoDB 操作日志 (oplog)。要创建 oplog，您需要部署一个副本集 (如果没有副本集)。有关更多信息，请参阅 [MongoDB 文档](https://docs.mongodb.com/manual/tutorial/deploy-replica-set/)。 您可以将 CDC 用于作为源终端节点的 MongoDB 副本集的主要或次要节点。 **将独立实例转换为副本集** 1. 使用命令行，连接到 `mongo`。 ``` mongo localhost ``` 1. 停止 `mongod` 服务。 ``` service mongod stop ``` 1. 使用以下命令重新启动 `mongod`： ``` mongod --replSet "rs0" --auth -port port_number ``` 1. 使用以下命令测试与副本集的连接： ``` mongo -u root -p password --host rs0/localhost:port_number --authenticationDatabase "admin" ``` 如果您打算执行文档模式迁移，请在创建 MongoDB 终端节点时选择选项 `_id as a separate column`。通过选择此选项，将创建另一个名为 `_id` 的列以作为主键。第二列是支持数据操作语言 (DML) 操作所 AWS DMS 必需的。 **注意** AWS DMS 使用操作日志 (oplog) 捕获正在进行的复制期间的更改。如果 MongoDB 在读取记录 AWS DMS 之前将其从操作日志中清除，则您的任务将失败。我们建议调整 oplog 的大小，将更改至少保留 24 小时。 ## 使用 MongoDB 作为源时的安全要求 AWS DMS AWS 分布式消息服务支持两种针对 MongoDB 的身份验证方法。这两种身份验证方法用于加密密码，因此它们仅在将 `authType` 参数设置为 *PASSWORD* 时使用。 MongoDB 身份验证方法如下： + **MONGODB-CR** – 提供向后兼容性 + **SCRAM-SHA-1** – 使用 MongoDB 版本 3.x 和 4.0 时的默认值 如果未指定身份验证方法，则 AWS DMS 将使用 MongoDB 源版本的默认方法。 ## 对 MongoDB 集合进行分段并以并行方式迁移 为了提高迁移任务的性能，MongoDB 源端点支持表映射中的并行完全加载的两个选项。 换句话说，在 JSON 设置中，对于并行完全加载，您可以使用表映射的自动分段或范围分段来迁移集合。通过自动分段，您可以指定标准， AWS DMS 以便在每个线程中自动对源进行细分以进行迁移。通过范围分割，您可以告知 AWS DMS DMS 要在每个线程中迁移的每个分段的具体范围。有关这些设置的更多信息，请参阅[表和集合设置规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)。 ### 使用自动分段范围并行迁移 MongoDB 数据库 您可以并行迁移文档，方法是为 AWS DMS 指定标准，以便为每个线程自动分区（分段）数据。具体而言，您指定每个线程要迁移的文档数量。使用这种方法， AWS DMS 尝试优化分段边界，以最大限度地提高每个线程的性能。 您可以在表映射中，使用以下表设置选项来指定分段标准： | 表设置选项 | 说明 | | --- | --- | | `"type"` | （必需）对于将 MongoDB 作为源，设置为 `"partitions-auto"`。 | | `"number-of-partitions"` | （可选）迁移使用的分区（区段）总数。默认值是 16。 | | `"collection-count-from-metadata"` | （可选）如果此选项设置为 `true`，则 AWS DMS 使用估计的集合计数来确定分区数。如果此选项设置为`false`，则 AWS DMS 使用实际收集次数。默认值为 `true`。 | | `"max-records-skip-per-page"` | （可选）在确定每个分区的边界时要同时跳过的记录数。 AWS DMS 使用分页跳过方法来确定分区的最小边界。默认值是 10000。 设置一个相对较大的值，会导致游标超时和任务失败。设置一个相对较低的值，会导致每页的操作次数增加，完全加载速度降低。 | | `"batch-size"` | （可选）限制一个批处理返回的文档数量。每个批处理需要往返一次服务器。如果批处理大小为零（0），则游标使用服务器定义的最大批处理大小。默认值是 0。 | 以下示例显示了自动分段的表映射。 ``` { "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "admin", "table-name": "departments" }, "rule-action": "include", "filters": [] }, { "rule-type": "table-settings", "rule-id": "2", "rule-name": "2", "object-locator": { "schema-name": "admin", "table-name": "departments" }, "parallel-load": { "type": "partitions-auto", "number-of-partitions": 5, "collection-count-from-metadata": "true", "max-records-skip-per-page": 1000000, "batch-size": 50000 } } ] } ``` 自动分段有以下限制。每个区段的迁移分别提取集合计数和集合的最小 `_id`。然后，它使用分页跳过来计算该区段的最小边界。 因此，请确保每个集合的最小 `_id` 值保持不变，直到计算出集合中的所有区段边界。如果在区段边界计算期间更改集合的最小 `_id` 值，则会导致数据丢失或重复行错误。 ### 使用范围分段并行迁移 MongoDB 数据库 您可以通过为线程中的每个区段指定范围来并行迁移文档。使用这种方法，您可以根据您选择 AWS DMS 的每个线程的文档范围来告知要在每个线程中迁移的特定文档。 下图显示了包含七个项目并将 `_id` 作为主键的 MongoDB 集合。 ![\[包含七个项目的 MongoDB 集合。\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-docdb-collection.png) 要将集合拆分为三个特定的段 AWS DMS 以便并行迁移，可以在迁移任务中添加表映射规则。此方法如以下 JSON 示例所示。 ``` { // Task table mappings: "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "testdatabase", "table-name": "testtable" }, "rule-action": "include" }, // "selection" :"rule-type" { "rule-type": "table-settings", "rule-id": "2", "rule-name": "2", "object-locator": { "schema-name": "testdatabase", "table-name": "testtable" }, "parallel-load": { "type": "ranges", "columns": [ "_id", "num" ], "boundaries": [ // First segment selects documents with _id less-than-or-equal-to 5f805c97873173399a278d79 // and num less-than-or-equal-to 2. [ "5f805c97873173399a278d79", "2" ], // Second segment selects documents with _id > 5f805c97873173399a278d79 and // _id less-than-or-equal-to 5f805cc5873173399a278d7c and // num > 2 and num less-than-or-equal-to 5. [ "5f805cc5873173399a278d7c", "5" ] // Third segment is implied and selects documents with _id > 5f805cc5873173399a278d7c. ] // :"boundaries" } // :"parallel-load" } // "table-settings" :"rule-type" ] // :"rules" } // :Task table mappings ``` 该表映射定义将源集合拆分为三个区段以并行迁移。以下是分段边界。 ``` Data with _id less-than-or-equal-to "5f805c97873173399a278d79" and num less-than-or-equal-to 2 (2 records) Data with _id > "5f805c97873173399a278d79" and num > 2 and _id less-than-or-equal-to "5f805cc5873173399a278d7c" and num less-than-or-equal-to 5 (3 records) Data with _id > "5f805cc5873173399a278d7c" and num > 5 (2 records) ``` 迁移任务完成后，您可以从任务日志中验证表是否并行加载，如以下示例所示。您还可以验证用于从源表中卸载每个区段的 MongoDB `find` 子句。 ``` [TASK_MANAGER ] I: Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86 (replicationtask_util.c:752) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is initialized. (mongodb_unload.c:157) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } } (mongodb_unload.c:328) [SOURCE_UNLOAD ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent. [TASK_MANAGER ] I: Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86 (replicationtask_util.c:752) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is initialized. (mongodb_unload.c:157) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } } (mongodb_unload.c:328) [SOURCE_UNLOAD ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent. [TARGET_LOAD ] I: Load finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 1 rows received. 0 rows skipped. Volume transfered 480. [TASK_MANAGER ] I: Load finished for segment #1 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. 2 records transferred. ``` 目前， AWS DMS 支持以下 MongoDB 数据类型作为分段键列： + 双精度 + String + ObjectId + 32 位整数 + 64 位整数 ## 使用 MongoDB 作为源时迁移多个数据库 AWS DMS AWS DMS 3.4.5 及更高版本支持在单个任务中为所有支持的 MongoDB 版本迁移多个数据库。如果您要迁移多个数据库，请采取以下步骤： 1. 在创建 MongoDB 源端点时，请执行下列操作之一： + 在 DMS 控制台的**创建端点**页面上，确保**端点配置**下的**数据库名称**为空。 + 使用 AWS CLI `CreateEndpoint`命令为中的`DatabaseName`参数分配一个空字符串值`MongoDBSettings`。 1. 对于要从 MongoDB 源迁移的每个数据库，请在任务的表映射中指定数据库名称作为架构名称。您可以在控制台中使用引导式输入或直接在 JSON 中执行此操作。有关引导式输入的更多信息，请参阅[通过控制台指定表选择和转换规则](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)。有关 JSON 的更多信息，请参阅[选择规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)。 例如，您可以指定以下 JSON 以迁移三个 MongoDB 数据库。 **Example 迁移架构中的所有表** 以下 JSON 会将源端点中 `Customers`、`Orders` 和 `Suppliers` 数据库的所有表迁移到目标端点。 ``` { "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "Customers", "table-name": "%" }, "rule-action": "include", "filters": [] }, { "rule-type": "selection", "rule-id": "2", "rule-name": "2", "object-locator": { "schema-name": "Orders", "table-name": "%" }, "rule-action": "include", "filters": [] }, { "rule-type": "selection", "rule-id": "3", "rule-name": "3", "object-locator": { "schema-name": "Inventory", "table-name": "%" }, "rule-action": "include", "filters": [] } ] } ``` ## 使用 MongoDB 作为源代码时的限制 AWS DMS 以下是使用 MongoDB 作为源代码时的限制： AWS DMS + 在表模式下，集合中的文档的数据类型，必须与所用于的同一字段中值的数据类型一致。例如，如果集合中的文档包含 `'{ a:{ b:value ... }'`，则集合中引用 `a.b` 字段 `value` 的所有文档都必须为 `value` 使用相同的数据类型，无论该文档出现在集合中的哪个位置。 + 当 `_id` 选项设置为单独一列时，ID 字符串不能超过 200 个字符。 + 在表模式下，对象 ID 和数组类型键将转换为具有 `oid` 和 `array` 前缀的列。 将使用具有前缀的名称在内部引用这些列。如果您在引用这些列 AWS DMS 时使用转换规则，请务必指定前缀列。例如，指定 `${oid__id}` 而不是 `${_id}`，或者指定 `${array__addresses}` 而不是 `${_addresses}`。 + 集合名称和键名不能包含美元符号（\$1）。 + AWS DMS 在表格模式下，不支持包含具有不同大小写（大小）的相同字段的集合，目标为 RDBMS。例如， AWS DMS 不支持将两个名为`Field1`和的集合`field1`。 + 表模式和文档模式具有前面所述的限制。 + 使用自动分段进行并行迁移时，存在上述限制。 + MongoDB 不支持源筛选器。 + AWS DMS 不支持嵌套级别大于 97 的文档。 + AWS DMS 迁移到非 DocumentDB 目标时需要使用 UTF-8 编码的源数据。对于包含非 UTF-8 字符的来源，请在迁移之前将其转换为 UTF-8，或者改为迁移到 Amazon DocumentDB。 + AWS DMS 不支持 MongoDB 版本 5.0 的以下功能： + 实时重新分片 + 客户端字段级加密（CSFLE） + 时间序列集合迁移 **注意** 由于 DocumentDB 不支持时间序列集合，因此在完全加载阶段中迁移的时间序列集合将转换为 Amazon DocumentDB 中的普通集合。 ## 使用 MongoDB 作为源时的端点配置设置 AWS DMS 设置 MongoDB 源端点时，您可以使用控制台指定多个端点配置设置。 AWS DMS 下表描述了使用 MongoDB 数据库作为源时可用的配置设置。 AWS DMS | 设置（属性） | 有效值 | 默认值和描述 | | --- | --- | --- | | **身份验证模式** | `"none"` `"password"` | 值 `"password"` 提示输入用户名和密码。如果指定 `"none"`，则不使用用户名和密码参数。 | | **身份验证源** | 有效的 MongoDB 数据库名称。 | 您为身份验证所用凭证进行验证时使用的 MongoDB 数据库的名称。默认值为 `"admin"`。 | | **身份验证机制** | `"default"` `"mongodb_cr"` `"scram_sha_1"` | 身份验证机制。` "default"` 值为 `"scram_sha_1"`。当 `authType` 设为 `"no"` 时，不使用此设置。 | | **元数据模式** | 文档和表 | 选择文档模式或表模式。 | | **要扫描的文档数**（`docsToInvestigate`） | 大于 `0` 的正整数。 | 仅在表模式下使用此选项来定义目标表定义。 | | **将 \$1id 作为单独的列** | 复选框中的选中标记 | 可选的复选标记框，用于创建另一个名为 `_id` 的列作为主键。 | | `ExtractDocID` | `true` `false` | `false` – 当 `NestingLevel` 设为 `"none"` 时使用此属性。 对产生[多文档交易](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction)的来源使用 CDC 时，**必须**将`ExtractDocId`参数设置为。`true`如果未启用此参数，则 AWS DMS 任务在遇到多文档事务时将失败。 | | `socketTimeoutMS` | 大于或等于 0 的整数。 仅限额外连接属性（ECA）。 | 此设置以毫秒为单位，用于配置 MongoDB 客户端的连接超时。如果该值小于或等于零，则使用 MongoDB 客户端默认值。 | | `UseUpdateLookUp` | `true` `false` | 如果为 true，则在 CDC 更新事件期间，将整个更新的文档 AWS DMS 复制到目标。设置为 false 时， AWS DMS 使用 MongoDB update 命令仅更新目标上文档中已修改的字段。 | | `ReplicateShardCollections` | `true` `false` | 如果为 true， AWS DMS 则将数据复制到分片集合。 AWS DMS 仅当目标终端节点是 DocumentDB 弹性集群时才使用此设置。 当此项设置为 true 时，请注意以下几点： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.MongoDB.html) | | `useTransactionVerification` | `true` `false` | 当为 `false` 时，禁用更改流和操作日志之间的验证。 如果更改流和操作日志条目之间出现差异，则可能会错过操作，因为在这种情况下，DMS 的默认行为是使任务失败。默认值：`true`。 | | `useOplog` | `true` `false` | 当为 `true` 时，使 DMS 任务直接从“oplog”中读取，而不是使用更改流。默认值：`false`。 | 如果您选择**文档**作为**元数据模式**，则可以使用不同的选项。 如果目标端点是 DocumentDB，请确保在**文档**模式下运行迁移。此外，修改您的源端点并选择选项**将 \$1id 作为单独的列**。如果您的源 MongoDB 工作负载涉及事务，则这是必需的先决条件。 ## MongoDB 的源数据类型 使用 MongoDB 作为源的数据迁移 AWS DMS 支持大多数 MongoDB 数据类型。在下表中，您可以找到 AWS DMS 使用时支持的 MongoDB 源数据类型以及数据类型的默认映射 AWS DMS 。有关 MongoDB 数据类型的更多信息，请参阅 MongoDB 文档中的 [BSON 类型](https://docs.mongodb.com/manual/reference/bson-types)。 有关如何查看目标中映射的数据类型的信息，请参阅有关所使用的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | MongoDB 数据类型 | AWS DMS 数据类型 | | --- | --- | | 布尔值 | 布尔型 | | 二元 | BLOB | | 日期 | 日期 | | 时间戳 | 日期 | | Int | INT4 | | 长整型 | INT8 | | 双精度 | REAL8 | | 字符串 (UTF-8) | CLOB | | 数组 | CLOB | | OID | 字符串 | | REGEX | CLOB | | 代码 | CLOB | # 使用亚马逊 DocumentDB（兼容 MongoDB）作为来源 AWS DMS 有关 AWS DMS 支持将哪些版本的 Amazon DocumentDB（与 MongoDB 兼容）作为源的信息，请参阅 [的来源 AWS DMS](CHAP_Introduction.Sources.md)。 使用 Amazon DocumentDB 作为源，您可以将数据从一个 Amazon DocumentDB 集群迁移到另一个 Amazon DocumentDB 集群。您也可以将数据从 Amazon DocumentDB 集群迁移到支持的其他目标终端节点之一。 AWS DMS 如果您不熟悉 Amazon DocumentDB，请注意 Amazon DocumentDB 的以下重要概念： + Amazon DocumentDB 中的记录是一个*文档*，它是由字段和值对构成的数据结构。字段值可以包含其他文档、数组和文档数组。文档大致相当于关系数据库表中的行。 + Amazon DocumentDB 中的*集合*是一组文档，并且大致相当于关系数据库表。 + Amazon DocumentDB 中的*数据库*是一组集合，并且大致相当于关系数据库中的架构。 AWS DMS 使用 Amazon DocumentDB 作为源代码时，支持两种迁移模式：文档模式和表格模式。在 AWS DMS 控制台中创建 Amazon DocumentDB 源终端节点时，您可以使用**元数据模式**选项或额外连接属性来指定迁移模式。`nestingLevel`在下文中，您可以找到有关迁移模式的选择如何影响所生成的目标数据格式的说明。 **文档模式** 在*文档模式下*，JSON 文档按原样迁移。这意味着文档数据将合并到两个项目之一中。当您使用关系数据库作为目标时，数据是目标表中名为 `_doc` 的单个列。当您使用非关系数据库作为目标时，数据是单个 JSON 文档。默认模式为文档模式，我们建议在迁移到 Amazon DocumentDB 目标时使用这种模式。 例如，请考虑名为 `myCollection` 的 Amazon DocumentDB 集合中的以下文档。 ``` db.myCollection.find() { "_id" : ObjectId("5a94815f40bd44d1b02bdfe0"), "a" : 1, "b" : 2, "c" : 3 } { "_id" : ObjectId("5a94815f40bd44d1b02bdfe1"), "a" : 4, "b" : 5, "c" : 6 } ``` 在使用文档模式将数据迁移到关系数据库表后，数据结构如下所示。文档中的数据字段将整合到 ` _doc` 列中。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.DocumentDB.html) 您可以选择将额外连接属性 `extractDocID` 设置为 `true`，以创建第二个名为 `"_id"` 的列作为主键。如果您要使用更改数据捕获（CDC），请将此参数设置为 `true`，除非使用 Amazon DocumentDB 作为目标。 对生成[多文档交易](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction)的来源使用 CDC 时，**必须**将`ExtractDocId`参数设置为。`true`如果未启用此参数，则 AWS DMS 任务在遇到多文档事务时将失败。 如果向源数据库添加新集合，则会为该集合 AWS DMS 创建一个新的目标表并复制所有文档。 **表模式** 在*表模式*中，AWS DMS 将 Amazon DocumentDB 文档中的每个顶级字段转换为目标表中的一个列。如果字段是嵌套的，则将嵌套值 AWS DMS 展平为一列。 AWS DMS 然后将关键字段和数据类型添加到目标表的列集中。 对于每个 Amazon DocumentDB 文档， AWS DMS 将每个键和类型添加到目标表的列集中。例如，使用表格模式，将前面的示例 AWS DMS 迁移到下表中。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.DocumentDB.html) 嵌套值平展到包含键名 (以句点分隔) 的列中。该列通过联接平展字段名（由句点分隔）来命名。例如， AWS DMS 将包含嵌套值字段（例如嵌套值）的 JSON 文档迁移`{"a" : {"b" : {"c": 1}}}`到名为的列中 `a.b.c.` 要创建目标列，请 AWS DMS 扫描指定数量的 Amazon DocumentDB 文档，然后创建一组包含所有字段及其类型。 AWS DMS 然后使用此集合来创建目标表的列。如果您使用控制台创建或修改 Amazon DocumentDB 源端点，则可指定要扫描的文档的数量。默认值为 1000 个文档。如果使用 AWS CLI，则可以使用额外的连接属性`docsToInvestigate`。 在表格模式下，像这样 AWS DMS 管理文档和集合： + 当您将一个文档添加到现有集合时，将复制该文档。如果某些字段在目标中不存在，则不会复制这些字段。 + 当您更新文档时，复制更新后的文档。如果某些字段在目标中不存在，则不会复制这些字段。 + 完全支持文档删除。 + 在 CDC 任务期间，添加新集合不会导致在目标上生成新的表。 + 在更改数据捕获 (CDC) 阶段， AWS DMS 不支持重命名集合。 **Topics** + [设置权限以使用 Amazon DocumentDB 作为源](#CHAP_Source.DocumentDB.Permissions) + [为 Amazon DocumentDB 集群配置 CDC](#CHAP_Source.DocumentDB.ConfigureCDC) + [使用 TLS 连接到 Amazon DocumentDB](#CHAP_Source.DocumentDB.TLS) + [创建 Amazon DocumentDB 源端点](#CHAP_Source.DocumentDB.ConfigureEndpoint) + [对 Amazon DocumentDB 集合进行分段并以并行方式迁移](#CHAP_Source.DocumentDB.ParallelLoad) + [使用 Amazon DocumentDB 作为源时迁移多个数据库 AWS DMS](#CHAP_Source.DocumentDB.Multidatabase) + [使用亚马逊 DocumentDB 作为来源时的限制 AWS DMS](#CHAP_Source.DocumentDB.Limitations) + [在以 Amazon DocumentDB 为源时使用端点设置](#CHAP_Source.DocumentDB.ECAs) + [Amazon DocumentDB 的源数据类型](#CHAP_Source.DocumentDB.DataTypes) ## 设置权限以使用 Amazon DocumentDB 作为源 使用 Amazon DocumentDB 源代码进行 AWS DMS 迁移时，您可以创建具有根权限的用户账户。或者，您可以创建一个仅具有待迁移数据库权限的用户。 以下代码创建作为根账户的用户。 ``` use admin db.createUser( { user: "root", pwd: "password", roles: [ { role: "root", db: "admin" } ] }) ``` 对于 Amazon DocumentDB 3.6，以下代码创建在要迁移的数据库上具有最低权限的用户。 ``` use db_name db.createUser( { user: "dms-user", pwd: "password", roles: [{ role: "read", db: "db_name" }] } ) ``` 对于 Amazon DocumentDB 4.0 及更高版本， AWS DMS 使用部署范围内的更改流。此处，以下代码创建具有最小权限的用户。 ``` db.createUser( { user: "dms-user", pwd: "password", roles: [ { role: "readAnyDatabase", db: "admin" }] }) ``` ## 为 Amazon DocumentDB 集群配置 CDC 要将持续复制或 CDC 与 Amazon DocumentDB 配合使用， AWS DMS 需要访问亚马逊文档数据库集群的变更流。有关集群的集合和数据库中按时间排列的更新事件序列的描述，请参阅**《Amazon DocumentDB 开发人员指南》中的[使用更改流](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html)。 使用 MongoDB Shell 对您的 Amazon DocumentDB 集群进行身份验证。然后运行以下命令以启用更改流。 ``` db.adminCommand({modifyChangeStreams: 1, database: "DB_NAME", collection: "", enable: true}); ``` 这种方法可以为您数据库中的所有集合启用更改流。启用更改流后，您可以创建迁移任务来迁移现有数据，同时复制正在进行的更改。 AWS DMS 即使加载了批量数据，仍会继续捕获和应用更改。最终，源数据库和目标数据库将保持同步，尽可能减少迁移的停机时间。 **注意** AWS DMS 使用操作日志 (oplog) 捕获正在进行的复制期间的更改。如果 Amazon DocumentDB 在 AWS DMS 读取操作日志之前将其从操作日志中清除，则您的任务将失败。我们建议调整 oplog 的大小，将更改至少保留 24 小时。 ## 使用 TLS 连接到 Amazon DocumentDB 默认情况下，新创建的 Amazon DocumentDB 集群仅接受使用传输层安全性协议（TLS）的安全连接。当 TLS 启用时，每个到 Amazon DocumentDB 的连接都需要公有密钥。 您可以通过`rds-combined-ca-bundle.pem`从托管的 Amazon AWS S3 存储桶下载文件来检索 Amazon DocumentDB 的公钥。有关下载此文件的更多信息，请参阅**《Amazon DocumentDB 开发人员指南》中的[使用 TLS 加密连接](https://docs.aws.amazon.com/documentdb/latest/developerguide/security.encryption.ssl.html)。 下载`rds-combined-ca-bundle.pem`文件后，可以将其包含的公钥导入到 AWS DMS。以下步骤说明了如何完成此操作。 **使用 AWS DMS 控制台导入您的公钥** 1. 登录 AWS 管理控制台 并选择 AWS DMS。 1. 在导航窗格中，选择**证书**。 1. 选择**导入证书**。此时显示**导入新 CA 证书**页面。 1. 在**证书配置**部分中，执行下列操作之一： + 对于**证书标识符**，请输入证书的唯一名称，例如 `docdb-cert`。 + 选择**选择文件**，导航到您保存 `rds-combined-ca-bundle.pem` 文件的位置，然后选择该文件。 1. 选择 **Add new CA certificate (添加新 CA 证书)**。 AWS CLI 以下示例使用 AWS DMS `import-certificate`命令导入公钥`rds-combined-ca-bundle.pem`文件。 ``` aws dms import-certificate \ --certificate-identifier docdb-cert \ --certificate-pem file://./rds-combined-ca-bundle.pem ``` ## 创建 Amazon DocumentDB 源端点 您可以使用控制台或 AWS CLI创建 Amazon DocumentDB 源端点。通过控制台使用以下过程。 **使用控制台配置 Amazon DocumentDB 源终端节点 AWS DMS** 1. 登录 AWS 管理控制台 并选择 AWS DMS。 1. 在导航窗格中，选择**端点**，然后选择**创建端点**。 1. 对于**端点标识符**，请提供一个可以帮助您轻松识别端点的名称，例如 `docdb-source`。 1. 对于**源引擎**，请选择 **Amazon DocumentDB（与 MongoDB 兼容）**。 1. 对于**服务器名称**，请输入您的 Amazon DocumentDB 数据库端点所在的服务器的名称。例如，您可以输入 Amazon EC2 实例的公有 DNS 名称，如 `democluster.cluster-cjf6q8nxfefi.us-east-2.docdb.amazonaws.com`。 1. 对于**端口**，输入 27017。 1. 对于 **SSL mode (SSL 模式)**，请选择 **verify-full**。如果您已经在 Amazon DocumentDB 集群上禁用 SSL，则可以跳过此步骤。 1. 对于 **CA 证书**，请选择 Amazon DocumentDB 证书 `rds-combined-ca-bundle.pem`。有关添加此证书的说明，请参阅[使用 TLS 连接到 Amazon DocumentDB](#CHAP_Source.DocumentDB.TLS)。 1. 对于**数据库名称**，请输入要迁移的数据库的名称。 通过 CLI 使用以下过程。 **使用配置亚马逊文档数据库源终端节点 AWS CLI** + 运行以下 AWS DMS `create-endpoint`命令来配置 Amazon DocumentDB 源终端节点，使用您自己的值替换占位符。 ``` aws dms create-endpoint \ --endpoint-identifier a_memorable_name \ --endpoint-type source \ --engine-name docdb \ --username value \ --password value \ --server-name servername_where_database_endpoint_resides \ --port 27017 \ --database-name name_of_endpoint_database ``` ## 对 Amazon DocumentDB 集合进行分段并以并行方式迁移 为了提高迁移任务的性能，Amazon DocumentDB 源端点支持表映射中的并行完全加载功能的两个选项。换句话说，在 JSON 设置中，对于并行完全加载，您可以使用表映射的自动分段或范围分段选项来迁移集合。自动分段选项允许您指定在每个话题中自动分段源 AWS DMS 以进行迁移的标准。范围分割选项允许您告知 DMS 要 AWS DMS 在每个线程中迁移的每个分段的具体范围。有关这些设置的更多信息，请参阅[表和集合设置规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)。 ### 使用自动分段范围并行迁移 Amazon DocumentDB 数据库 您可以并行迁移文档，方法是为 AWS DMS 指定标准，以便按照每个线程要迁移的文档数量，为每个线程自动分区（分段）数据。使用这种方法， AWS DMS 尝试优化区段边界，以最大限度地提高每个线程的性能。 您可以在表映射中使用以下表设置选项来指定分段标准： | 表设置选项 | 说明 | | --- | --- | | `"type"` | （必需）对于将 Amazon DocumentDB 作为源，设置为 `"partitions-auto"`。 | | `"number-of-partitions"` | （可选）迁移使用的分区（区段）总数。默认值是 16。 | | `"collection-count-from-metadata"` | （可选）如果设置为`true`，则 AWS DMS 使用估计的收集计数来确定分区数。如果设置为`false`，则 AWS DMS 使用实际收集次数。默认值为 `true`。 | | `"max-records-skip-per-page"` | （可选）在确定每个分区的边界时要同时跳过的记录数。 AWS DMS 使用分页跳过方法来确定分区的最小边界。默认值是 10000。设置一个相对较大的值，可能会导致游标超时和任务失败。设置一个相对较低的值，会导致每页的操作次数增加，完全加载速度降低。 | | `"batch-size"` | （可选）限制一个批处理返回的文档数量。每个批处理需要往返一次服务器。如果批处理大小为零（0），则游标使用服务器定义的最大批处理大小。默认值是 0。 | 以下示例显示了自动分段的表映射。 ``` { "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "admin", "table-name": "departments" }, "rule-action": "include", "filters": [] }, { "rule-type": "table-settings", "rule-id": "2", "rule-name": "2", "object-locator": { "schema-name": "admin", "table-name": "departments" }, "parallel-load": { "type": "partitions-auto", "number-of-partitions": 5, "collection-count-from-metadata": "true", "max-records-skip-per-page": 1000000, "batch-size": 50000 } } ] } ``` 自动分段有以下限制。每个区段的迁移分别提取集合计数和集合的最小 `_id`。然后，它使用分页跳过来计算该区段的最小边界。因此，请确保每个集合的最小 `_id` 值保持不变，直到计算出集合中的所有区段边界。如果在区段边界计算期间更改集合的最小 `_id` 值，则可能会导致数据丢失或重复行错误。 ### 使用特定区段范围并行迁移 Amazon DocumentDB 数据库 以下示例显示了包含七个项目并将 `_id` 作为主键的 Amazon DocumentDB 集合。 ![\[包含七个项目的 Amazon DocumentDB 集合。\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-docdb-collection.png) 要将集合拆分为三个区段以并行迁移，可以在迁移任务中添加表映射规则，如以下 JSON 示例所示。 ``` { // Task table mappings: "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "testdatabase", "table-name": "testtable" }, "rule-action": "include" }, // "selection" :"rule-type" { "rule-type": "table-settings", "rule-id": "2", "rule-name": "2", "object-locator": { "schema-name": "testdatabase", "table-name": "testtable" }, "parallel-load": { "type": "ranges", "columns": [ "_id", "num" ], "boundaries": [ // First segment selects documents with _id less-than-or-equal-to 5f805c97873173399a278d79 // and num less-than-or-equal-to 2. [ "5f805c97873173399a278d79", "2" ], // Second segment selects documents with _id > 5f805c97873173399a278d79 and // _id less-than-or-equal-to 5f805cc5873173399a278d7c and // num > 2 and num less-than-or-equal-to 5. [ "5f805cc5873173399a278d7c", "5" ] // Third segment is implied and selects documents with _id > 5f805cc5873173399a278d7c. ] // :"boundaries" } // :"parallel-load" } // "table-settings" :"rule-type" ] // :"rules" } // :Task table mappings ``` 该表映射定义将源集合拆分为三个区段以并行迁移。以下是分段边界。 ``` Data with _id less-than-or-equal-to "5f805c97873173399a278d79" and num less-than-or-equal-to 2 (2 records) Data with _id less-than-or-equal-to "5f805cc5873173399a278d7c" and num less-than-or-equal-to 5 and not in (_id less-than-or-equal-to "5f805c97873173399a278d79" and num less-than-or-equal-to 2) (3 records) Data not in (_id less-than-or-equal-to "5f805cc5873173399a278d7c" and num less-than-or-equal-to 5) (2 records) ``` 迁移任务完成后，您可以从任务日志中验证表是否并行加载，如以下示例所示。您还可以验证用于从源表中卸载每个区段的 Amazon DocumentDB `find` 子句。 ``` [TASK_MANAGER ] I: Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86 (replicationtask_util.c:752) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is initialized. (mongodb_unload.c:157) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } } (mongodb_unload.c:328) [SOURCE_UNLOAD ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent. [TASK_MANAGER ] I: Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86 (replicationtask_util.c:752) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is initialized. (mongodb_unload.c:157) [SOURCE_UNLOAD ] I: Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } } (mongodb_unload.c:328) [SOURCE_UNLOAD ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent. [TARGET_LOAD ] I: Load finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 1 rows received. 0 rows skipped. Volume transfered 480. [TASK_MANAGER ] I: Load finished for segment #1 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. 2 records transferred. ``` 目前， AWS DMS 支持以下 Amazon DocumentDB 数据类型作为区段键列： + 双精度 + String + ObjectId + 32 位整数 + 64 位整数 ## 使用 Amazon DocumentDB 作为源时迁移多个数据库 AWS DMS AWS DMS 3.4.5 及更高版本仅支持在单个任务中迁移多个数据库，仅适用于 Amazon DocumentDB 版本 4.0 及更高版本。如果要迁移多个数据库，请执行以下操作： 1. 创建 Amazon DocumentDB 源端点时： + 在 f AWS 管理控制台 or 中 AWS DMS，将**创建**终端节点页面上的 “**端点配置**” 下的**数据库名称**留空。 + 在 AWS Command Line Interface (AWS CLI) 中，为 D **oc DBSettings** umen **DatabaseName**t 中为**CreateEndpoint**操作指定的参数分配一个空字符串值。 1. 对于要从此 Amazon DocumentDB 源端点迁移的每个数据库，使用控制台中的指导式输入或直接以 JSON 格式输入，将每个数据库的名称指定为任务的表映射中的架构名称。有关指导式输入的更多信息，请参阅[通过控制台指定表选择和转换规则](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)中的描述。有关 JSON 的更多信息，请参阅[选择规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)。 例如，您可以指定以下 JSON 以迁移三个 Amazon DocumentDB 数据库。 **Example 迁移架构中的所有表** 以下 JSON 会将源端点中 `Customers`、`Orders` 和 `Suppliers` 数据库的所有表迁移到目标端点。 ``` { "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "Customers", "table-name": "%" }, "object-locator": { "schema-name": "Orders", "table-name": "%" }, "object-locator": { "schema-name": "Inventory", "table-name": "%" }, "rule-action": "include" } ] } ``` ## 使用亚马逊 DocumentDB 作为来源时的限制 AWS DMS 以下是使用亚马逊 DocumentDB 作为来源时的限制： AWS DMS + 当 `_id` 选项设置为单独一列时，ID 字符串不能超过 200 个字符。 + 在表模式下，对象 ID 和数组类型键将转换为具有 `oid` 和 `array` 前缀的列。 将使用具有前缀的名称在内部引用这些列。如果您在引用这些列 AWS DMS 时使用转换规则，请务必指定前缀列。例如，指定 `${oid__id}` 而不是 `${_id}`，或者指定 `${array__addresses}` 而不是 `${_addresses}`。 + 集合名称和键名不能包含美元符号（\$1）。 + 表模式和文档模式具有前面讨论的限制。 + 使用自动分段进行并行迁移时，存在上述限制。 + Amazon DocumentDB（兼容 MongoDB）源不支持使用特定的时间戳作为更改数据捕获（CDC）的起始位置。无论时间戳如何，持续复制任务都会开始捕获更改。 + AWS DMS 对于低于 3.5.2 的 AWS DMS 版本，不支持嵌套级别大于 97 的文档。 + DocumentDB 不支持源筛选器。 + AWS DMS 在弹性集群模式下，不支持 DocumentDB 的 CDC（更改数据捕获）复制作为源。 ## 在以 Amazon DocumentDB 为源时使用端点设置 您可以使用端点设置来配置 Amazon DocumentDB 源数据库，这与使用额外连接属性类似。您可以在使用 AWS DMS 控制台创建源端点时指定设置，或者使用中带有 `--doc-db-settings '{"EndpointSetting": "value", ...}'` JSON 语法的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)命令来指定设置。 下表显示了在将 Amazon DocumentDB 用作源时可以使用的端点设置。 | 属性名称 | 有效值 | 默认值和描述 | | --- | --- | --- | | `NestingLevel` | `"none"` `"one"` | `"none"` – 指定 `"none"` 以使用文档模式。指定 `"one"` 使用表模式。 | | `ExtractDocID` | `true` `false` | `false` – 当 `NestingLevel` 设为 `"none"` 时使用此属性。 对生成[多文档交易](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction)的来源使用 CDC 时，**必须**将`ExtractDocId`参数设置为。`true`如果未启用此参数，则 AWS DMS 任务在遇到多文档事务时将失败。 | | `DocsToInvestigate` | 大于 `0` 的正整数。 | `1000` – 当 `NestingLevel` 设为 `"one"` 时使用此属性。 | | `ReplicateShardCollections ` | `true` `false` | 如果为 true， AWS DMS 则将数据复制到分片集合。 AWS DMS 仅当目标终端节点是 DocumentDB 弹性集群时才使用此设置。 当此项设置为 true 时，请注意以下几点： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.DocumentDB.html) | ## Amazon DocumentDB 的源数据类型 在下表中，您可以找到使用 AWS DMS时支持的 Amazon DocumentDB 源数据类型。您还可以在此表中找到 AWS DMS 数据类型的默认映射。有关数据类型的更多信息，请参阅 MongoDB 文档中的 [BSON 类型](https://docs.mongodb.com/manual/reference/bson-types)。 有关如何查看目标中映射的数据类型的信息，请参阅有关所使用的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | Amazon DocumentDB 数据类型 | AWS DMS 数据类型 | | --- | --- | | 布尔值 | 布尔型 | | 二元 | BLOB | | 日期 | 日期 | | 时间戳 | 日期 | | Int | INT4 | | 长整型 | INT8 | | 双精度 | REAL8 | | 字符串 (UTF-8) | CLOB | | 数组 | CLOB | | OID | 字符串 | # 使用 Amazon S3 作为来源 AWS DMS 您可以使用从 Amazon S3 存储桶迁移数据 AWS DMS。为此，请提供对包含一个或多个数据文件的 Amazon S3 存储桶的访问。在该 S3 存储桶中，请包含一个 JSON 文件以描述该数据与这些文件中的数据的数据库表之间的映射。 在开始完全加载之前，必须在 Amazon S3 存储桶中包含源数据文件。您可以使用 `bucketName` 参数指定存储桶名称。 源数据文件可以采用如下格式： + 逗号分隔值（.csv） + Parquet（DMS 版本 3.5.3 及更高版本）。有关使用 Parquet 格式文件的信息，请参阅 [使用 Amazon S3 中的拼木地板格式文件作为来源 AWS DMS](#CHAP_Source.S3.Parquet)。 对于逗号分隔值（.csv）格式的源数据文件，请使用以下命名约定命名它们。在该约定中，*`schemaName`* 是源架构，*`tableName`* 是该架构中的表的名称。 ``` /schemaName/tableName/LOAD001.csv /schemaName/tableName/LOAD002.csv /schemaName/tableName/LOAD003.csv ... ``` 例如，假定数据文件位于以下 Amazon S3 路径的 `amzn-s3-demo-bucket` 中。 ``` s3://amzn-s3-demo-bucket/hr/employee ``` 加载时， AWS DMS 假设源架构名称为`hr`，源表名为`employee`。 除了`bucketName`（必填项）之外，您还可以选择提供一个`bucketFolder`参数来指定 AWS DMS 应在 Amazon S3 存储桶中查找数据文件的位置。继续前面的示例，如果您设置`bucketFolder`为`sourcedata`，则 AWS DMS 读取以下路径中的数据文件。 ``` s3://amzn-s3-demo-bucket/sourcedata/hr/employee ``` 您可以使用额外连接属性指定列分隔符、行分隔符、null 值指示符以及其他参数。有关更多信息，请参阅 [Amazon S3 的终端节点设置作为来源 AWS DMS](#CHAP_Source.S3.Configuring)。 您可以使用 `ExpectedBucketOwner` Amazon S3 端点设置指定存储桶拥有者并防止狙击，如下所示。然后，当您发出测试连接或执行迁移的请求时，S3 会根据指定参数检查存储桶拥有者的账户 ID。 ``` --s3-settings='{"ExpectedBucketOwner": "AWS_Account_ID"}' ``` **Topics** + [将 Amazon S3 的外部表定义为数据源 AWS DMS](#CHAP_Source.S3.ExternalTableDef) + [使用 CDC 和 Amazon S3 作为来源 AWS DMS](#CHAP_Source.S3.CDC) + [使用 Amazon S3 作为来源的先决条件 AWS DMS](#CHAP_Source.S3.Prerequisites) + [使用 Amazon S3 作为来源时的限制 AWS DMS](#CHAP_Source.S3.Limitations) + [Amazon S3 的终端节点设置作为来源 AWS DMS](#CHAP_Source.S3.Configuring) + [Amazon S3 的源数据类型](#CHAP_Source.S3.DataTypes) + [使用 Amazon S3 中的拼木地板格式文件作为来源 AWS DMS](#CHAP_Source.S3.Parquet) ## 将 Amazon S3 的外部表定义为数据源 AWS DMS 除了数据文件以外，您还必须提供外部表定义。*外部表定义是一个* JSON 文档，它描述了 AWS DMS 应如何解释 Amazon S3 中的数据。该文档的最大大小为 2 MB。如果您使用 AWS DMS 管理控制台创建源端点，则可以直接在表映射框中输入 JSON。如果您使用 AWS Command Line Interface (AWS CLI) 或 AWS DMS API 执行迁移，则可以创建一个 JSON 文件来指定外部表的定义。 假定您具有包含以下内容的数据文件。 ``` 101,Smith,Bob,2014-06-04,New York 102,Smith,Bob,2015-10-08,Los Angeles 103,Smith,Bob,2017-03-13,Dallas 104,Smith,Bob,2017-03-13,Dallas ``` 以下是该数据的示例外部表定义。 ``` { "TableCount": "1", "Tables": [ { "TableName": "employee", "TablePath": "hr/employee/", "TableOwner": "hr", "TableColumns": [ { "ColumnName": "Id", "ColumnType": "INT8", "ColumnNullable": "false", "ColumnIsPk": "true" }, { "ColumnName": "LastName", "ColumnType": "STRING", "ColumnLength": "20" }, { "ColumnName": "FirstName", "ColumnType": "STRING", "ColumnLength": "30" }, { "ColumnName": "HireDate", "ColumnType": "DATETIME" }, { "ColumnName": "OfficeLocation", "ColumnType": "STRING", "ColumnLength": "20" } ], "TableColumnsTotal": "5" } ] } ``` 该 JSON 文档中的元素如下所示： `TableCount` – 源表数。在该示例中，只有一个表。 `Tables` – 一个数组，对于每个源表，它包含一个 JSON 映射。在该示例中，只有一个映射。每个映射包含以下元素： + `TableName` – 源表的名称。 + `TablePath` – AWS DMS 可以在 Amazon S3 存储桶中找到完整数据加载文件的路径。如果指定了 `bucketFolder` 值，则在路径前面添加其值。 + `TableOwner` – 该表的架构名称。 + `TableColumns` – 包含一个或多个映射的数组，每个映射描述源表中的一个列： + `ColumnName` – 源表中的列的名称。 + `ColumnType` – 列的数据类型。有关有效的数据类型，请参阅[Amazon S3 的源数据类型](#CHAP_Source.S3.DataTypes)。 + `ColumnLength` – 该列中的字节数。由于 S3 源不支持完整 LOB 模式，因此最大列长度限制为 2147483647 字节 (2,047 MegaBytes)。 `ColumnLength`对以下数据类型有效： + BYTE + string + `ColumnNullable` – 一个布尔值；如果该列可以包含 NULL 值，则此值为 `true`（默认值为 `false`）。 + `ColumnIsPk` – 一个布尔值；如果该列是主键的一部分，则此值为 `true`（默认值为 `false`）。 + `ColumnDateFormat` – 具有 DATE、TIME 和 DATETIME 类型的列的输入日期格式，用于将数据字符串解析为日期对象。可能的值包括： ``` - YYYY-MM-dd HH:mm:ss - YYYY-MM-dd HH:mm:ss.F - YYYY/MM/dd HH:mm:ss - YYYY/MM/dd HH:mm:ss.F - MM/dd/YYYY HH:mm:ss - MM/dd/YYYY HH:mm:ss.F - YYYYMMdd HH:mm:ss - YYYYMMdd HH:mm:ss.F ``` + `TableColumnsTotal` – 总列数。该数字必须与 `TableColumns` 数组中的元素数相匹配。 如果您未另行指定，则 AWS DMS 假定`ColumnLength`为零。 **注意** 在支持的版本中 AWS DMS，S3 源数据还可以包含一个可选的操作列，作为列值之前的第一`TableName`列。此操作列标识在完全加载期间用于将数据迁移到 S3 目标终端节点的操作 (`INSERT`)。 如果存在，则此列的值是 `INSERT` 操作关键字的第一个字符 (`I`)。如果指定，则此列通常指示在之前的迁移中 DMS 创建的 S3 源作为 S3 目标。 在 3.4.2 之前的 DMS 版本中，通过以前的 DMS 完全加载创建的 S3 源数据中没有此列。将此列添加到 S3 目标数据可以使得写入 S3 目标的所有行的格式保持一致，不论它们是在完全加载还是 CDC 加载期间写入。有关格式化 S3 目标数据的选项的更多信息，请参阅[指示迁移的 S3 数据中的源数据库操作](CHAP_Target.S3.md#CHAP_Target.S3.Configuring.InsertOps)。 对于 NUMERIC 类型的列，指定精度和小数位数。*精度* 是数字中的总位数，而*小数位数* 是小数点右边的位数。为此，您可以使用 `ColumnPrecision` 和 `ColumnScale` 元素，如下所示。 ``` ... { "ColumnName": "HourlyRate", "ColumnType": "NUMERIC", "ColumnPrecision": "5" "ColumnScale": "2" } ... ``` 对于数据包含小数秒的 DATETIME 类型的列，请指定小数位数。*小数位数*是小数秒的位数，范围可以从 0 到 9。为此，您可以使用 `ColumnScale` 元素，如下所示。 ``` ... { "ColumnName": "HireDate", "ColumnType": "DATETIME", "ColumnScale": "3" } ... ``` 如果未另行指定，则 AWS DMS 假定`ColumnScale`为零并截断小数秒。 ## 使用 CDC 和 Amazon S3 作为来源 AWS DMS AWS DMS 执行完整数据加载后，它可以选择将数据更改复制到目标端点。为此，您需要将变更数据捕获文件（CDC 文件）上传到您的 Amazon S3 存储桶。 AWS DMS 在上传这些 CDC 文件时读取它们，然后将更改应用到目标端点。 CDC 文件是按如下方式命名的： ``` CDC00001.csv CDC00002.csv CDC00003.csv ... ``` **注意** 要在更改数据文件夹中成功地复制 CDC 文件，请按词汇（序列）顺序上传它们。例如，在.csv 文件之前上传 CDC00002 .csv 文件 CDC00003。否则，如果您在 CDC00002 .csv 之后 CDC00003加载.csv，则会跳过且不会对其进行复制。但是，如果在 CDC00004 .csv 之后 CDC00003加载.csv 文件，则可以成功复制。 要指明在哪里 AWS DMS 可以找到文件，请指定`cdcPath`参数。对于前面的示例，如果将 `cdcPath` 设置为 `changedata`，则 AWS DMS 读取以下路径中的 CDC 文件。 ``` s3://amzn-s3-demo-bucket/changedata ``` 如果将 `cdcPath` 设置为 `changedata`，并将 `bucketFolder` 设置为 `myFolder`， AWS DMS 会读取以下路径中的 CDC 文件。 ``` s3://amzn-s3-demo-bucket/myFolder/changedata ``` CDC 文件中的记录格式如下所示： + 操作 – 要执行的更改操作：`INSERT`（`I`）、`UPDATE`（`U`）或 `DELETE`（`D`）。这些关键字和字符值不区分大小写。 **注意** 在支持的 AWS DMS 版本中， AWS DMS 可以通过两种方式识别每个加载记录要执行的操作。 AWS DMS 可以根据记录的关键字值（例如`INSERT`）或其关键字的初始字符（例如`I`）执行此操作。在之前的版本中，只能从完整的关键字值中 AWS DMS 识别加载操作。 在的先前版本中 AWS DMS，写入了完整的关键字值来记录 CDC 数据。以前的版本仅使用关键字首字母将操作值写入任何 S3 目标。 无论如何写入操作列 AWS DMS 来创建 S3 源数据，都可以识别这两种格式来处理操作。此方法支持使用 S3 目标数据作为源用于以后的迁移。借助这种方法，您无需更改以后 S3 源的操作列中显示的任意关键字首字母值的格式。 + 表名称 – 源表的名称。 + 架构名称 – 源架构的名称。 + 数据 – 表示要更改的数据的一个或多个列。 以下是名为 `employee` 的表的示例 CDC 文件。 ``` INSERT,employee,hr,101,Smith,Bob,2014-06-04,New York UPDATE,employee,hr,101,Smith,Bob,2015-10-08,Los Angeles UPDATE,employee,hr,101,Smith,Bob,2017-03-13,Dallas DELETE,employee,hr,101,Smith,Bob,2017-03-13,Dallas ``` ## 使用 Amazon S3 作为来源的先决条件 AWS DMS 要使用 Amazon S3 作为来源 AWS DMS，您的源 S3 存储桶必须与迁移数据的 DMS 复制实例位于同一 AWS 区域。此外，用于迁移的 AWS 账户必须具有源存储桶的读取访问权限。对于 AWS DMS 版本 3.4.7 及更高版本，DMS 必须通过 VPC 终端节点或公共路由访问源存储桶。有关 VPC 端点的信息，请参阅 [配置 VPC 终端节点 AWS DMS](CHAP_VPC_Endpoints.md)。 分配给用于创建迁移任务的用户账户的 AWS Identity and Access Management (IAM) 角色必须具有以下权限集。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket*/*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket*" ] } ] } ``` ------ 如果在 Amazon S3 存储桶上启用了版本控制，则分配给用于创建迁移任务的用户账户的 AWS Identity and Access Management (IAM) 角色必须具有以下权限集。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket*/*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket*" ] } ] } ``` ------ ## 使用 Amazon S3 作为来源时的限制 AWS DMS 将 Amazon S3 作为源时存在以下限制： + 不要为 S3 启用版本控制。如果您需要 S3 版本控制，请使用生命周期策略主动删除旧版本。否则，您可能会遇到由于 S3 `list-object` 调用超时而导致端点测试连接失败的情况。要为 S3 存储桶创建生命周期策略，请参阅[管理存储生命周期](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html)。要删除 S3 对象的某个版本，请参阅[从启用版本控制的存储桶中删除对象版本](https://docs.aws.amazon.com/AmazonS3/latest/dev/DeletingObjectVersions.html)。 + 3.4.7 及更高版本支持启用了 VPC（网关 VPC）的 S3 存储桶。 + MySQL 将 `time` 数据类型转换为 `string`。要在 MySQL 中查看 `time` 数据类型值，请将目标表中的列定义为 `string`，然后将任务的**目标表准备模式**设置设为**截断**。 + AWS DMS 在内部对两种`BYTE`数据类型`BYTE`和数据类型都使用该`BYTES`数据类型。 + S3 源端点不支持 DMS 表重新加载特征。 + AWS DMS 不支持以 Amazon S3 作为源的完整 LOB 模式。 在作为源的 Amazon S3 中使用 Parquet 格式文件时存在以下限制： + S3 Parquet 源日期分区特征不支持 `MMYYYYDD` 或 `DDMMYYYY` 格式的日期。 ## Amazon S3 的终端节点设置作为来源 AWS DMS 您可以使用端点设置来配置 Amazon S3 源数据库，这与使用额外连接属性类似。您可以在使用 AWS DMS 控制台创建源端点时指定设置，或者使用中带有 `--s3-settings '{"EndpointSetting": "value", ...}'` JSON 语法的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)命令来指定设置。 **注意** AWS DMS 默认为与 Amazon S3 终端节点的安全连接，无需指定 SSL 模式或证书。 下表显示了将 Amazon S3 作为源时可以使用的端点设置。 | **选项** | **描述** | | --- | --- | | BucketFolder | (可选) S3 存储桶中的文件夹名称。如果提供该属性，则分别从 `s3://amzn-s3-demo-bucket/bucketFolder/schemaName/tableName/` 和 `s3://amzn-s3-demo-bucket/bucketFolder/` 路径中读取源数据文件和 CDC 文件。如果未指定此属性，则使用的路径为 `schemaName/tableName/`。 `'{"BucketFolder": "sourceData"}'` | | BucketName | S3 桶的名称。 `'{"BucketName": "amzn-s3-demo-bucket"}'` | | CdcPath | CDC 文件的位置。如果任务捕获更改数据，则该属性是必需的，否则，该属性是可选的。如果CdcPath存在，则从此路径 AWS DMS 读取 CDC 文件并将数据更改复制到目标端点。有关更多信息，请参阅 [使用 CDC 和 Amazon S3 作为来源 AWS DMS](#CHAP_Source.S3.CDC)。`'{"CdcPath": "changeData"}'` | | CsvDelimiter | 源文件中用于分隔列的分隔符。默认值为逗号。下面是一个示例。 `'{"CsvDelimiter": ","}'` | | CsvNullValue | 用户定义的字符串， AWS DMS 从源读取时将其视为 null。默认值是空字符串。如果未设置此参数，则 AWS DMS 会将空字符串视为空值。如果将此参数设置为诸如 “\$1 N” 之类的字符串，则 AWS DMS 会将此字符串视为空值，并将空字符串视为空字符串值。 | | CsvRowDelimiter | 源文件中用于分隔行的分隔符。默认值为换行符 (`\n`)。 `'{"CsvRowDelimiter": "\n"}'` | | DataFormat | 将此值设置为 `Parquet` 可读取 Parquet 格式的数据。 `'{"DataFormat": "Parquet"}'` | | IgnoreHeaderRows | 当此值设置为 1 时，将 AWS DMS 忽略.csv 文件中的第一行标题。值为 1 可启用该功能，值为 0 将禁用该功能。 默认值是 0。 `'{"IgnoreHeaderRows": 1}'` | | Rfc4180 | 当此值设置为 `true` 或 `y` 时，每个前导双引号必须后跟一个结束双引号。此格式符合 RFC 4180。当此值设置为 `false` 或 `n`时，字符串文字将按原样复制到目标。在这种情况下，分隔符（行或列）表示字段的末尾。因此，您不能使用分隔符作为字符串的一部分，因为它表示值的末尾。 默认值为 `true`。 有效值：`true`、`false`、`y`、`n` `'{"Rfc4180": false}'` | ## Amazon S3 的源数据类型 使用 Amazon S3 作为数据源的数据迁移 AWS DMS 需要将数据从 Amazon S3 映射到 AWS DMS 数据类型。有关更多信息，请参阅 [将 Amazon S3 的外部表定义为数据源 AWS DMS](#CHAP_Source.S3.ExternalTableDef)。 有关如何查看目标中映射的数据类型的信息，请参阅有关所使用的目标终端节点的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 以下 AWS DMS 数据类型用于 Amazon S3 作为数据源： + BYTE – 需要 `ColumnLength`。有关更多信息，请参阅 [将 Amazon S3 的外部表定义为数据源 AWS DMS](#CHAP_Source.S3.ExternalTableDef)。 + DATE + TIME + DATETIME – 有关更多信息和示例，请参阅 [将 Amazon S3 的外部表定义为数据源 AWS DMS](#CHAP_Source.S3.ExternalTableDef) 中的 DATETIME 类型示例。 + INT1 + INT2 + INT4 + INT8 + 数字-需要`ColumnPrecision`和`ColumnScale`。 AWS DMS 支持以下最大值： + **ColumnPrecision: 38** + **ColumnScale: 31** 有关更多信息和示例，请参阅 [将 Amazon S3 的外部表定义为数据源 AWS DMS](#CHAP_Source.S3.ExternalTableDef) 中的 NUMERIC 类型示例。 + REAL4 + REAL8 + STRING – 需要 `ColumnLength`。有关更多信息，请参阅 [将 Amazon S3 的外部表定义为数据源 AWS DMS](#CHAP_Source.S3.ExternalTableDef)。 + UINT1 + UINT2 + UINT4 + UINT8 + BLOB + CLOB + BOOLEAN ## 使用 Amazon S3 中的拼木地板格式文件作为来源 AWS DMS 在 3.5.3 及更高 AWS DMS 版本中，您可以使用 S3 存储桶中的 Parquet 格式文件作为满载或 CDC 复制的来源。 DMS 仅支持 Parquet 格式文件作为 DMS 通过将数据迁移到 S3 目标端点而生成的源。文件名必须采用支持的格式，否则 DMS 不会将其包含在迁移中。 Parquet 格式的源数据文件必须位于以下文件夹并遵守以下命名约定。 ``` schema/table1/LOAD00001.parquet schema/table2/LOAD00002.parquet schema/table2/LOAD00003.parquet ``` 对于 Parquet 格式的 CDC 数据的源数据文件，请使用以下文件夹和命名约定对其进行命名和存储。 ``` schema/table/20230405-094615814.parquet schema/table/20230405-094615853.parquet schema/table/20230405-094615922.parquet ``` 要访问 Parquet 格式文件，请设置以下端点设置： + 将 `DataFormat` 设置为 `Parquet`。 + 请勿设置 `cdcPath` 设置。确保在指定的架构/表文件夹中创建 Parquet 格式文件。 有关 S3 端点设置的更多信息，请参阅《AWS Database Migration Service API 参考》**中的 [S3Settings](https://docs.aws.amazon.com/dms/latest/APIReference/API_S3Settings.html)。 ### Parquet 格式文件支持的数据类型 AWS DMS 从 Parquet 格式文件迁移数据时，支持以下源和目标数据类型。迁移之前，请确保目标表中包含正确数据类型的列。 | 源数据类型 | 目标数据类型 | | --- | --- | | BYTE | BINARY | | DATE | DATE32 | | TIME | TIME32 | | DATETIME | TIMESTAMP | | INT1 | INT8 | | INT2 | INT16 | | INT4 | INT32 | | INT8 | INT64 | | NUMERIC | DECIMAL | | REAL4 | FLOAT | | REAL8 | DOUBLE | | STRING | STRING | | UINT1 | UINT8 | | UINT2 | UINT16 | | UINT4 | UINT32 | | UINT8 | UINT | | WSTRING | STRING | | BLOB | BINARY | | NCLOB | STRING | | CLOB | STRING | | BOOLEAN | BOOL | # 使用适用于 Linux、Unix、Windows 的 IBM Db2 和亚马逊 RDS 数据库 (Db2 LUW) 作为来源 AWS DMS 您可以使用 () 将数据从适用于 Linux、Unix、Windows 和 Amazon RDS (Db2 LUW) 的 IBM Db AWS Database Migration Service 2 数据库迁移到任何支持的目标数据库。AWS DMS 有关 AWS DMS 支持作为源的 Linux、Unix、Windows 和 RDS 上的 Db2 版本的信息，请参阅[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 可以使用安全套接字层 (SSL) 加密 Db2 LUW 端点与复制实例之间的连接。有关将 SSL 用于 Db2 LUW 终端节点的更多信息，请参阅[将 SSL 与 AWS Database Migration Service](CHAP_Security.SSL.md)。 从 IBM Db2 源数据库 AWS DMS 读取数据时，它会使用 Db2 版本 9.7 及更高版本的默认隔离级别 CURSOR STABILITY (CS)。有关更多信息，请参阅[适用于 Linux、UNIX 和 Windows 的 IBM Db2](https://www.ibm.com/docs/en/db2/12.1.0) 文档。 ## 使用 Db2 LUW 作为源时的先决条件 AWS DMS 需要先满足以下先决条件，然后才能将 Db2 LUW 数据库作为源。 要启用持续复制（也称为更改数据捕获 (CDC)），请执行以下操作： + 将数据库设置为可恢复，这 AWS DMS 需要捕获更改。如果数据库配置参数 `LOGARCHMETH1` 和/或 `LOGARCHMETH2` 设置为 `ON`，则数据库是可恢复的。 如果您的数据库是可恢复的，则 AWS DMS 可以在`ARCHIVE LOG`需要时访问 Db2。 + 确保 DB2 事务日志可用，并有足够的保留期供其处理 AWS DMS。 + DB2 需要`SYSADM`或`DBADM`授权才能提取事务日志记录。向用户账户授予以下权限： + `SYSADM` 或 `DBADM` + `DATAACCESS` **注意** 对于仅完全加载任务，DMS 用户账户需要 DATAACCESS 权限。 + 使用 IBM f DB2 or LUW 版本 9.7 作为源时，请按`CurrentLsn`如下方式设置额外连接属性 (ECA)： `CurrentLsn=LSN`，这里的 `LSN` 指定要在其中启动复制的日志序列号（LSN）。或者 `CurrentLsn=scan`。 + 使用 Amazon RDS for Db2 LUW 作为源时，请确保存档日志可供使用。 AWS DMS由于 AWS托管的 Db2 数据库会尽快清除存档日志，因此您应该延长日志的可用时间。例如，要将日志保留时间延长至 24 小时，请运行以下命令： ``` db2 "call rdsadmin.set_archive_log_retention( ?, 'TESTDB', '24')" ``` 有关 Amazon RDS for Db2 LUW 过程的更多信息，请参阅《Amazon Relational Database Service 用户指南》**中的 [Amazon RDS for Db2 存储过程参考](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/db2-stored-procedures.html)。 + 如果您使用特 DB2 定的预迁移评估，请授予以下权限： ``` GRANT CONNECT ON DATABASE TO USER ; GRANT SELECT ON SYSIBM.SYSDUMMY1 TO USER ; GRANT SELECT ON SYSIBMADM.ENV_INST_INFO TO USER ; GRANT SELECT ON SYSIBMADM.DBCFG TO USER ; GRANT SELECT ON SYSCAT.SCHEMATA TO USER ; GRANT SELECT ON SYSCAT.COLUMNS TO USER ; GRANT SELECT ON SYSCAT.TABLES TO USER ; GRANT EXECUTE ON FUNCTION SYSPROC.AUTH_LIST_AUTHORITIES_FOR_AUTHID TO ; GRANT EXECUTE ON PACKAGE NULLID.SYSSH200 TO USER ; ``` ## 使用 Db2 LUW 作为源代码时的限制 AWS DMS AWS DMS 不支持群集数据库。但是，您可以为集群的每个终端节点定义一个单独的 Db2 LUW。例如，您可以使用集群中的任何一个节点创建完全加载迁移任务，然后从每个节点创建单独的任务。 AWS DMS 不支持您的源 Db2 LUW 数据库中的`BOOLEAN`数据类型。 在使用持续复制 (CDC) 时，以下限制将适用： + 当包含多个分区的表被截断时， AWS DMS 控制台中显示的 DDL 事件数等于分区数。这是因为 Db2 LUW 为每个分区记录一个单独的 DDL。 + 已分区表上不支持以下 DDL 操作： + ALTER TABLE ADD PARTITION + ALTER TABLE DETACH PARTITION + ALTER TABLE ATTACH PARTITION + AWS DMS 不支持从 DB2高可用性灾难恢复 (HADR) 备用实例进行持续的复制迁移。备用实例无法访问。 + 不支持 DECFLOAT 数据类型。因此，在持续复制期间，将忽略对 DECFLOAT 列所做的更改。 + 不支持 RENAME COLUMN 语句。 + 对多维聚类 (MDC) 表执行更新时，每次更新都会在 AWS DMS 控制台中显示为 INSERT \$1 DELETE。 + 如果未启用任务设置 **Include LOB columns in replication (在复制中包含 LOB 列)**，则将在持续复制期间暂停任何具有 LOB 列的表。 + 对于 Db2 LUW 版本 10.5 及更高版本，将忽略包含存储数据的可变长度字符串列。 out-of-row此限制仅适用于对于具有 VARCHAR 和 VARGRAPHIC 等数据类型的列，那些使用扩展行大小创建的表。要解决此限制，请将表移至具有较大页面大小的表格空间。有关更多信息，请参阅[如果我想更改 DB2 表空间的页面大小，该怎么办]( https://www.ibm.com/support/pages/what-can-i-do-if-i-want-change-pagesize-db2-tablespaces )。 + 对于持续复制，DMS 不支持迁移 LOAD 实用程序在页面级别 DB2 加载的数据。相反，请使用 IMPORT 实用程序，该实用程序使用 SQL 插入。有关更多信息，请参阅 [IMPORT 和 LOAD 实用程序之间的区别]( https://www.ibm.com/docs/en/db2/11.1?topic=utilities-differences-between-import-load-utility)。 + 在运行复制任务时， DDLs 只有在创建表时使用 DATA CAPTURE CHANGE 属性创建时，DMS 才会捕获 CREATE TABLE。 + DMS 在使用 Db2 数据库分区特征（DPF）时有以下限制： + 在 DPF 环境中，DMS 无法在 Db2 节点之间协调事务。这是由于 IBM DB2 READLOG API 接口中的限制造成的。在 DPF 中，事务可能跨越多个 Db2 节点，具体取决于数据的 DB2 分区方式。因此，您的 DMS 解决方案必须独立地从每个 Db2 节点捕获事务。 + 通过在多个 DMS 源端点上将 `connectNode` 设置为 `1`，DMS 可以从 DPF 集群中的每个 Db2 节点捕获本地事务。此配置对应于 DB2 服务器配置文件中定义的逻辑节点号`db2nodes.cfg`。 + 单个 Db2 节点上的本地事务可能是更大的全局事务的一部分。DMS 在目标上独立应用每个本地事务，无需与其他 Db2 节点上的事务进行协调。这种独立的处理可能会增加复杂性，尤其是在分区之间移动行时。 + 当 DMS 从多个 Db2 节点复制时，无法保证目标上的操作顺序正确，因为 DMS 会独立地为每个 Db2 节点应用操作。您必须确保独立地从每个 Db2 节点捕获本地事务适用于您的特定使用案例。 + 从 DPF 环境迁移时，建议先运行不带缓存事件的完全加载任务，然后运行仅 CDC 任务。我们建议每个 Db2 节点运行一个任务，从您使用`StartFromContext`端点额外连接属性设置的满载开始时间戳或 LRI（日志记录标识符）开始。有关确定复制开始点的信息，请参阅 *IBM 支持文档*中的[查找复制开始的 LSN 或 LRI 值](https://www.ibm.com/support/pages/db2-finding-lsn-or-lri-value-replication-start)。 + 对于持续复制 (CDC)，如果您计划从特定时间戳开始复制，则必须将`StartFromContext`额外连接属性设置为所需的时间戳。 + 目前，DMS 不支持 Db2 pureScale 功能，该功能是 DB2 LUW 的扩展，可用于扩展数据库解决方案。 + `DATA CAPTURE CHANGES`表选项是 DB2 数据复制过程的关键先决条件。创建表时忽略启用此选项可能会导致数据丢失，特别是对于仅限从较早起点启动的 CDC（更改数据捕获）复制任务。 AWS DMS 将在重启 CDC 或 FULL\$1CDC 任务时默认启用此属性。但是，在任务重新启动之前在源数据库中所做的任何更改都可能被遗漏。 ``` ALTER TABLE TABLE_SCHEMA.TABLE_NAME DATA CAPTURE CHANGES INCLUDE LONGVAR COLUMNS; ``` ## 使用 Db2 LUW 作为源时的端点设置 AWS DMS 您可以在使用 AWS DMS 控制台创建源端点时指定设置，也可以使用中的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/create-endpoint.html)命令和 `--ibm-db2-settings '{"EndpointSetting1": "value1","EndpointSetting2": "value2"}'` JSON 语法。 下表显示了将 Db2 LUW 用作源时可以使用的端点设置。 | 设置名称 | 说明 | | --- | --- | | `CurrentLsn` | 对于持续复制 (CDC)，请使用 `CurrentLsn` 指定要在其中启动复制的日志序列号 (LSN)。 | | `MaxKBytesPerRead` | 每次读取的最大字节数，以 NUMBER 值表示。默认值为 64 KB。 | | `SetDataCaptureChanges` | 启用持续复制 (CDC) 作为 BOOLEAN 值。默认值为 true。 | ## 使用 Db2 LUW 作为源时的额外连接属性 (ECAs) AWS DMS 在使用 AWS DMS 控制台创建源端点时，可以指定额外连接属性 (ECAs)，也可以使用中的`create-endpoint`[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/create-endpoint.html)命令和 `--extra-connection-attributes 'ECAname1=value1;ECAname2=value2;'` 下表显示了可以 ECAs 与 Db2 LUW 一起用作源的。 | 属性名称 | 说明 | | --- | --- | | `ConnectionTimeout` | 使用此 ECA 设置 Db2 LUW 端点的端点连接超时（以秒为单位）。默认值为 10 秒。 示例：`ConnectionTimeout=30;` | | `executeTimeout` | 额外的连接属性，用于设置 DB2 LUW 端点的语句（查询）超时，以秒为单位。默认值为 60 秒。 示例：`executeTimeout=120;` | | `StartFromContext` | 对于持续复制（CDC），请使用 `StartFromContext` 指定日志的下限，复制将从此位置开始。`StartFromContext` 接受不同格式的值。有效值包括： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.DB2.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.DB2.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Source.DB2.html) 要确定日志文件的 LRI/LSN 范围，请按以下示例所示运行`db2flsn`命令。 
db2flsn -db SAMPLE -lrirange 2
该示例的输出类似于以下内容。 

S0000002.LOG: has LRI range 00000000000000010000000000002254000000000004F9A6 to 
000000000000000100000000000022CC000000000004FB13
在该输出中，日志文件为 S0000002 .LOG，**StartFromContext**LRI 值为范围末尾的 34 字节。 
0100000000000022CC000000000004FB13
| ## IBM Db2 LUW 的源数据类型 使用 Db2 LUW 作为源的数据迁移 AWS DMS 支持大多数 Db2 LUW 数据类型。下表显示了使用时支持的 Db2 LUW 源数据类型 AWS DMS 以及 AWS DMS 数据类型的默认映射。有关 Db2 LUW 数据类型的更多信息，请参阅 [Db2 LUW 文档](https://www.ibm.com/support/knowledgecenter/SSEPGG_10.5.0/com.ibm.db2.luw.sql.ref.doc/doc/r0008483.html)。 有关如何查看目标中映射的数据类型的信息，请参阅使用的目标终端节点对应的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | Db2 LUW 数据类型 | AWS DMS 数据类型 | | --- | --- | | INTEGER | INT4 | | SMALLINT | INT2 | | BIGINT | INT8 | | DECIMAL (p,s) | NUMERIC (p,s) | | FLOAT | REAL8 | | DOUBLE | REAL8 | | REAL | REAL4 | | DECFLOAT (p) | 如果精度为 16，则 REAL8；如果精度为 34，则为 STRING | | GRAPHIC (n) | WSTRING，用于长度大于 0 且小于或等于 127 个双字节字符的固定长度图形字符串 | | VARGRAPHIC (n) | WSTRING，用于长度大于 0 且小于或等于 16352 个双字节字符的可变长度图形字符串 | | LONG VARGRAPHIC (n) | CLOB，用于长度大于 0 且小于或等于 16352 个双字节字符的可变长度图形字符串 | | CHARACTER (n) | STRING，用于长度大于 0 且小于或等于 255 个双字节字符的固定长度字符串 | | VARCHAR (n) | STRING，用于长度大于 0 且小于或等于 32704 个双字节字符的可变长度字符串 | | LONG VARCHAR (n) | CLOB，用于长度大于 0 且小于或等于 32704 个双字节字符的可变长度字符串 | | CHAR (n) FOR BIT DATA | BYTES | | VARCHAR (n) FOR BIT DATA | BYTES | | LONG VARCHAR FOR BIT DATA | BYTES | | DATE | DATE | | TIME | TIME | | TIMESTAMP | DATETIME | | BLOB (n) | BLOB 最大长度为 2147483647 个字节 | | CLOB (n) | CLOB 最大长度为 2147483647 个字节 | | DBCLOB (n) | CLOB 最大长度为 1073741824 个双字节字符 | | XML | CLOB | # 使用 IBM Db2 作为 z/OS 数据库的来源 AWS DMS 您可以使用 AWS Database Migration Service (AWS DMS) 将数据从 IBM for z/OS 数据库迁移到任何支持的目标数据库。 有关 AWS DMS 支持作为源的 Db2 版本的信息，请参见[的来源 AWS DMS](CHAP_Introduction.Sources.md)。 z/OS ## 使用 Db2 z/OS 作为源代码时的先决条件 AWS DMS 要使用 z/OS 数据库的 IBM Db2 作为中的源 AWS DMS，请为在源端点连接设置中指定的 z/OS 用户向 Db2 授予以下权限。 ``` GRANT SELECT ON SYSIBM.SYSTABLES TO Db2USER; GRANT SELECT ON SYSIBM.SYSTABLESPACE TO Db2USER; GRANT SELECT ON SYSIBM.SYSTABLEPART TO Db2USER; GRANT SELECT ON SYSIBM.SYSCOLUMNS TO Db2USER; GRANT SELECT ON SYSIBM.SYSDATABASE TO Db2USER; GRANT SELECT ON SYSIBM.SYSDUMMY1 TO Db2USER ``` 还要授予 SELECT ON `user defined` 源表权限。 z/OS 源端点的 AWS DMS IBM Db2 依赖于 ODBC 的 IBM 数据服务器驱动程序来访问数据。数据库服务器必须具有有效的 IBM ODBC Connect 许可证，DMS 才能连接到此端点。 ## 使用 Db2 z/OS 作为源代码时的限制 AWS DMS 使用 IBM Db2 for z/OS 数据库作为源时，存在以下限制： AWS DMS + 仅支持完全加载复制任务。不支持更改数据捕获 (CDC)。 + 不支持并行加载。 + 不支持对视图进行数据验证。 + 在 Column/table 级别转换和行级选择筛选器的表映射中，必须以大写形式指定架构、表和列名称。 ## IBM Db2 for z/OS 的源数据类型 使用 Db2 z/OS 作为源的数据迁移 AWS DMS 支持大多数 Db2 的数据类型。 z/OS 下表显示了使用 AWS DMS时支持的 z/OS 源数据类型的 Db2 以及 AWS DMS 数据类型的默认映射。 有关 z/OS 数据类型的 Db2 的更多信息，请参阅 [IBM Db2 的文档。 z/OS ](https://www.ibm.com/docs/en/db2-for-zos/12?topic=elements-data-types) 有关如何查看目标中映射的数据类型的信息，请参阅使用的目标终端节点对应的部分。 有关 AWS DMS 数据类型的更多信息，请参见[AWS Database Migration Service 的数据类型](CHAP_Reference.DataTypes.md)。 | 适用于 z/OS 数据类型的 Db2 | AWS DMS 数据类型 | | --- | --- | | INTEGER | INT4 | | SMALLINT | INT2 | | BIGINT | INT8 | | DECIMAL (p,s) | NUMERIC (p,s) 如果在 DB2 配置中将小数点设置为逗号 (,)，请将 Replicate 配置为支持该 DB2 设置。 | | FLOAT | REAL8 | | DOUBLE | REAL8 | | REAL | REAL4 | | DECFLOAT (p) | 如果精度为 16，则 REAL8；如果精度为 34，则为 STRING | | GRAPHIC (n) | 如果 n>=127，则为 WSTRING，用于双字节字符的固定长度图形字符串，长度大于 0 且小于或等于 127 | | VARGRAPHIC (n) | WSTRING，用于长度大于 0 且小于或等于 16352 个双字节字符的可变长度图形字符串 | | LONG VARGRAPHIC (n) | CLOB，用于长度大于 0 且小于或等于 16352 个双字节字符的可变长度图形字符串 | | CHARACTER (n) | STRING，用于长度大于 0 且小于或等于 255 个双字节字符的固定长度字符串 | | VARCHAR (n) | STRING，用于长度大于 0 且小于或等于 32704 个双字节字符的可变长度字符串 | | LONG VARCHAR (n) | CLOB，用于长度大于 0 且小于或等于 32704 个双字节字符的可变长度字符串 | | CHAR (n) FOR BIT DATA | BYTES | | VARCHAR (n) FOR BIT DATA | BYTES | | LONG VARCHAR FOR BIT DATA | BYTES | | DATE | DATE | | TIME | TIME | | TIMESTAMP | DATETIME | | BLOB (n) | BLOB 最大长度为 2147483647 个字节 | | CLOB (n) | CLOB 最大长度为 2147483647 个字节 | | DBCLOB (n) | CLOB 最大长度为 1073741824 个双字节字符 | | XML | CLOB | | BINARY | BYTES | | VARBINARY | BYTES | | ROWID | BYTES。有关使用 ROWID 的更多信息，请参阅以下内容。 | | TIMESTAMP（有时区） | 不支持。 | 当任务的目标表准备模式设置为 DROP\$1AND\$1CREATE（默认）时，默认情况下会迁移 ROWID 列。数据验证会忽略这些列，因为这些行在特定的数据库和表之外毫无意义。要禁止迁移这些列，您可以执行下列准备步骤之一： + 预先创建不带这些列的目标表。然后，将任务的目标表格准备模式设置为 DO\$1NOTHING 或 TRUNCATE\$1BEFORE\$1LOAD。可以使用 AWS Schema Conversion Tool (AWS SCT) 预先创建不带列的目标表。 + 在任务中添加表映射规则筛选掉这些列，使其被忽略。有关更多信息，请参阅 [转换规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。 ## 适用于大型机现代化服务的 PostgreSQL 中的 EBCDIC 排序规则 AWS AWS 大型机现代化计划可帮助您将大型机应用程序现代化为 AWS 托管运行时环境。它提供了工具和资源来帮助您规划和实施迁移与现代化项目。有关大型机现代化和迁移的更多信息，请参阅[大型机现代化](https://aws.amazon.com/mainframe/)使用。 AWS 一些用于 z/OS 数据集的 IBM Db2 使用扩展二进制编码十进制交换 (EBCDIC) 字符集编码。这是一种在 ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）普遍使用之前开发的字符集。*代码页*将每个文本字符映射到字符集中的字符。传统的代码页包含代码点和字符 ID 之间的映射信息。*字符 ID* 是一个 8 字节的字符数据字符串。*代码点*是代表一个字符的 8 位二进制数。代码点通常以其二进制值的十六进制表示形式显示。 如果您目前使用的是 Micro Focus 或大型机现代化服务的 BluAge 组件，则必须告知 AWS DMS 要*移动*（翻译）某些代码点。您可以使用 AWS DMS 任务设置来执行轮班。以下示例说明如何使用该 AWS DMS `CharacterSetSettings`操作来映射 DMS 任务设置中的班次。 ``` "CharacterSetSettings": { "CharacterSetSupport": null, "CharacterReplacements": [ {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"} } ] } ``` PostgreSQL 已有一些 EBCDIC 排序规则可以理解所需的转换。系统支持几种不同的代码页。以下各节提供了一些 JSON 示例，说明在所有支持的代码页中必须转换的内容。您只需 copy-and-past在 DMS 任务中输入所需的 JSON 即可。 ### Micro Focus 特定的 EBCDIC 排序规则 对于 Micro Focus，请根据需要对以下排序规则的字符子集进行转换。 ``` da-DK-cp1142m-x-icu de-DE-cp1141m-x-icu en-GB-cp1146m-x-icu en-US-cp1140m-x-icu es-ES-cp1145m-x-icu fi-FI-cp1143m-x-icu fr-FR-cp1147m-x-icu it-IT-cp1144m-x-icu nl-BE-cp1148m-x-icu ``` **Example 各排序规则的 Micro Focus 数据转换：** **en\$1us\$1cp1140m** 代码转换： ``` 0000 0180 00A6 0160 00B8 0161 00BC 017D 00BD 017E 00BE 0152 00A8 0153 00B4 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1141m** 代码转换： ``` 0000 0180 00B8 0160 00BC 0161 00BD 017D 00BE 017E 00A8 0152 00B4 0153 00A6 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1142m** 代码转换： ``` 0000 0180 00A6 0160 00B8 0161 00BC 017D 00BD 017E 00BE 0152 00A8 0153 00B4 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1143m** 代码转换： ``` 0000 0180 00B8 0160 00BC 0161 00BD 017D 00BE 017E 00A8 0152 00B4 0153 00A6 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1144m** 代码转换： ``` 0000 0180 00B8 0160 00BC 0161 00BD 017D 00BE 017E 00A8 0152 00B4 0153 00A6 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1145m** 代码转换： ``` 0000 0180 00A6 0160 00B8 0161 00A8 017D 00BC 017E 00BD 0152 00BE 0153 00B4 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1146m** 代码转换： ``` 0000 0180 00A6 0160 00B8 0161 00BC 017D 00BD 017E 00BE 0152 00A8 0153 00B4 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1147m** 代码转换： ``` 0000 0180 00B8 0160 00A8 0161 00BC 017D 00BD 017E 00BE 0152 00B4 0153 00A6 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"} ``` **en\$1us\$1cp1148m** 代码转换： ``` 0000 0180 00A6 0160 00B8 0161 00BC 017D 00BD 017E 00BE 0152 00A8 0153 00B4 0178 ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"} ,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"} ,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"} ,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"} ,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"} ,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"} ,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"} ``` ### BluAge 特定的 EBCDIC 归类 对于 BluAge，根据需要移动以下所有*低值*和*高值*。这些归类只能用于支持大型机迁移 BluAge 服务。 ``` da-DK-cp1142b-x-icu da-DK-cp277b-x-icu de-DE-cp1141b-x-icu de-DE-cp273b-x-icu en-GB-cp1146b-x-icu en-GB-cp285b-x-icu en-US-cp037b-x-icu en-US-cp1140b-x-icu es-ES-cp1145b-x-icu es-ES-cp284b-x-icu fi-FI-cp1143b-x-icu fi-FI-cp278b-x-icu fr-FR-cp1147b-x-icu fr-FR-cp297b-x-icu it-IT-cp1144b-x-icu it-IT-cp280b-x-icu nl-BE-cp1148b-x-icu nl-BE-cp500b-x-icu ``` **Example BluAge 数据转移：** **da-DK-cp277b** 和 **da-DK-cp1142b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **de-DE-273b** 和 **de-DE-1141b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **en-GB-285b** 和 **en-GB-1146b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **en-us-037b** 和 **en-us-1140b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **es-ES-284b** 和 **es-ES-1145b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **fi\$1FI-278b** 和 **fi-FI-1143b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **fr-FR-297b** 和 **fr-FR-1147b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **it-IT-280b** 和 **it-IT-1144b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ``` **nl-BE-500b** 和 **nl-BE-1148b** 代码转换： ``` 0180 0180 0001 0181 0002 0182 0003 0183 009C 0184 0009 0185 0086 0186 007F 0187 0097 0188 008D 0189 008E 018A 000B 018B 000C 018C 000D 018D 000E 018E 000F 018F 0010 0190 0011 0191 0012 0192 0013 0193 009D 0194 0085 0195 0008 0196 0087 0197 0018 0198 0019 0199 0092 019A 008F 019B 001C 019C 001D 019D 001E 019E 001F 019F 0080 01A0 0081 01A1 0082 01A2 0083 01A3 0084 01A4 000A 01A5 0017 01A6 001B 01A7 0088 01A8 0089 01A9 008A 01AA 008B 01AB 008C 01AC 0005 01AD 0006 01AE 0007 01AF 0090 01B0 0091 01B1 0016 01B2 0093 01B3 0094 01B4 0095 01B5 0096 01B6 0004 01B7 0098 01B8 0099 01B9 009A 01BA 009B 01BB 0014 01BC 0015 01BD 009E 01BE 001A 01BF 009F 027F ``` AWS DMS 任务的相应输入映射： ``` {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"} ,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"} ,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"} ,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"} ,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"} ,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"} ,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"} ,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"} ,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"} ,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"} ,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"} ,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"} ,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"} ,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"} ,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"} ,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"} ,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"} ,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"} ,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"} ,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"} ,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"} ,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"} ,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"} ,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"} ,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"} ,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"} ,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"} ,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"} ,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"} ,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"} ,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"} ,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"} ,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"} ,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"} ,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"} ,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"} ,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"} ,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"} ,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"} ,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"} ,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"} ,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"} ,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"} ,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"} ,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"} ,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"} ,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"} ,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"} ,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"} ,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"} ,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"} ,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"} ,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"} ,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"} ,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"} ,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"} ,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"} ,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"} ,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"} ,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"} ,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"} ,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"} ,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"} ,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"} ,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"} ```