克隆 Amazon Aurora 数据库集群卷
使用 Aurora 克隆功能,您可以创建一个新集群,该集群最初与原始集群共享相同的数据页,但它是一个单独且独立的卷。该过程旨在快速且经济高效。我们将新集群及其关联的数据卷称为克隆。与使用其他技术(如还原快照)实际复制数据相比,创建克隆速度更快且空间利用效率更高。
主题
Aurora 克隆概述
Aurora 使用写入时复制协议创建克隆。此机制占用最少的额外空间来创建初始克隆。首次创建克隆时,Aurora 会保留源 Aurora 数据库集群和新(克隆的)Aurora 数据库集群使用的数据的单个副本。只有当源 Aurora 数据库集群或 Aurora 数据库集群克隆对数据(在 Aurora 存储卷上)进行更改时,才会分配额外的存储空间。如需了解有关写入时复制协议的更多信息,请参阅 Aurora 克隆的工作原理。
Aurora 克隆非常适合使用您的生产数据快速设置测试环境,且不会有损坏数据的风险。您可以将克隆用于多种类型的应用程序,例如:
-
对潜在的变化(例如模式变化和参数组变化)进行试验,以评估所有影响。
-
执行工作负载密集型操作,例如导出数据或在克隆上运行分析查询。
-
为开发、测试或其他用途创建生产数据库集群的副本。
您可以从同一个 Aurora 数据库集群创建多个克隆。您还可以从另一个克隆创建多个克隆。
创建 Aurora 克隆后,您可以以不同于源 Aurora 数据库集群的方式配置 Aurora 数据库实例。例如,您可能不需要用于开发目的的克隆来满足与源生产 Aurora 数据库集群相同的高可用性要求。在这种情况下,您可以使用单个 Aurora 数据库实例来配置克隆,而不是使用 Aurora 数据库集群使用的多个数据库实例。
当您使用与源不同的部署配置创建克隆时,将使用源的 Aurora 数据库引擎的最新次要版本创建克隆。
当您从 Aurora 数据库集群创建克隆时,将在您的AWS账户中创建克隆,该账户即是拥有源 Aurora 数据库集群的账户。但是,您也可以与其它 AWS 账户共享 Aurora Serverless v2 和预调配 Aurora 数据库集群和克隆。有关更多信息,请参阅 使用 AWS RAM 与 Amazon Aurora 进行跨账户克隆。
当克隆完成测试、开发等使用目的时,您可以将其删除。
Aurora 克隆的限制
Aurora 克隆具有以下限制:
-
您可以根据需要创建任意数量的克隆,最多为 AWS 区域中允许的最大数据库集群数。
您可以使用写入时复制协议或完全复制协议创建克隆。完全复制协议的作用类似于时间点恢复。
-
您不能在与源 Aurora 数据库集群不同的 AWS 区域中创建克隆。
-
不支持并行查询功能的 Aurora 数据库集群无法创建克隆到使用并行查询的集群。要将数据传输到使用并行查询的集群,请创建原始集群的快照,并将其还原到使用并行查询功能的集群。
-
您无法从没有数据库实例的 Aurora 数据库集群创建克隆。您只能克隆具有至少一个数据库实例的 Aurora 数据库集群。
-
您可以在与 Aurora 数据库集群不同的 Virtual Private Cloud (VPC) 中创建克隆。不过,这些 VPC 的子网必须映射到相同的可用区。
-
您可以从预置的 Aurora 数据库集群创建 Aurora 预置的克隆。
-
具有 Aurora Serverless v2 实例的集群遵循与预置集群相同的规则。
-
对于 Aurora Serverless v1:
-
您可以从 Aurora Serverless v1 数据库集群创建预调配克隆。
-
您可以从 Aurora Serverless v1 或预调配数据库集群创建 Aurora Serverless v1 克隆。
-
您无法从未加密的预调配 Aurora 数据库集群创建 Aurora Serverless v1 克隆。
-
跨账户克隆目前不支持克隆 Aurora Serverless v1 数据库集群。有关更多信息,请参阅 跨账户克隆的限制。
-
克隆的Aurora Serverless v1 数据库集群与其他 Aurora Serverless v1 数据库集群具有相同的行为和限制。有关更多信息,请参阅 使用 Amazon Aurora Serverless v1。
-
Aurora Serverless v1 数据库集群始终加密。当您将 Aurora Serverless v1 数据库集群克隆到预置的 Aurora 数据库集群时,配置的 Aurora 数据库集群将被加密。您可以选择加密密钥,但不能禁用加密。要从预调配 Aurora 数据库集群克隆到 Aurora Serverless v1,必须以加密的预调配 Aurora 数据库集群开始。
-
Aurora 克隆的工作原理
Aurora 克隆运行于 Aurora 数据库集群的存储层。它使用写入时复制协议,该协议在支持 Aurora 存储卷的底层持久介质方面既快速又节省空间。有关 Aurora 集群卷的更多信息,请参阅 Amazon Aurora 存储概述。
了解写入时复制协议
Aurora 数据库集群将数据存储在底层 Aurora 存储卷中的页面中。
例如,在下图中,您可以找到拥有四个数据页(1、2、3 和 4)的 Aurora 数据库集群(A)。假设从 Aurora 数据库集群创建了一个克隆 B。创建克隆时,未复制任何数据。相反,克隆指向与源 Aurora 数据库集群相同的页面集。
![Amazon Aurora 集群卷包含 4 个页面,适用于源集群 A 和克隆 B](images/aurora-cloning-copy-on-write-protocol-1.png)
创建克隆时,通常不需要额外的存储空间。写入时复制协议在物理存储介质上使用与源段相同的数据段。只有当源段的容量不足以容纳整个克隆段时,才需要额外的存储空间。如果是这种情况,源段将被复制到另一个物理设备。
在下图中,您可以找到使用相同集群 A 及其克隆 B 的写入操作时复制协议的示例,如前所示。如果您对 Aurora 数据库集群(A)进行更改,那么第 1 页上保存的数据也将随之而发生改变。Aurora 没有写入原始页面 1,而是创建了一个新页面 1[A]。集群(A)的 Aurora 数据库集群卷现在指向页面 1[A]、2、3 和 4,而克隆(B)仍引用原始页面。
![Amazon Aurora 源数据库集群卷及其克隆,均已更改。](images/aurora-cloning-copy-on-write-protocol-2.png)
在克隆上,对存储卷的第 4 页进行了更改。Aurora 没有写入原始页面 4,而是创建了一个新页面 4[B]。克隆现在指向页面 1、2、3 和页面 4[B],而集群(A)继续指向 1[A]、2、3 和 4。
![Amazon Aurora 源数据库集群卷及其克隆,均已更改。](images/aurora-cloning-copy-on-write-protocol-3.png)
随着时间推移,当源 Aurora 集群卷和克隆上出现了更多更改时,因此需要更多存储空间来捕获和存储更改。
删除源集群卷
最初,克隆卷与从中创建克隆的原始卷共享相同的数据页面。只要原始卷存在,克隆卷就只能被视为克隆创建或修改的页面的拥有者。因此,克隆卷的 VolumeBytesUsed
指标起初很小,只会随着原始集群和克隆之间的数据差异而增长。对于源卷和克隆之间相同的页面,存储费用仅适用于原始集群。有关 VolumeBytesUsed
指标的更多信息,请参阅Amazon Aurora 的集群级指标。
删除与一个或多个克隆关联的源集群卷时,不会更改克隆的集群卷中的数据。Aurora 保留以前由源集群卷拥有的页面。Aurora 会重新分配已删除集群所拥有的页面的存储计费。例如,假设一个原始集群有两个克隆,然后删除了原始集群。现在,原始集群拥有的数据页面中有一半将归一个克隆所拥有。另一半页面将归另一个克隆所拥有。
如果您删除原始集群,则当您创建或删除更多克隆时,Aurora 将继续在共享相同页面的所有克隆间重新分配数据页面的拥有权。因此,您可能会发现,克隆的集群卷的 VolumeBytesUsed
指标值发生变化。随着创建的克隆越来越多以及页面拥有权分布在更多集群中,此指标的值可能会降低。随着删除克隆以及页面拥有权分配给更少数量的集群,此指标的值也可能增加。有关写入操作如何影响克隆卷上的数据页面的信息,请参阅了解写入时复制协议。
当原始集群和克隆归同一个 AWS 账户拥有时,这些集群的所有存储费用都适用于该同一个 AWS 账户。如果某些集群是跨账户克隆,则删除原始集群可能会导致对拥有跨账户克隆的 AWS 账户收取额外的存储费用。
例如,假设一个集群卷在您创建任何克隆之前具有 1000 个已用数据页面。克隆该集群时,最初克隆卷的已用页面数为零。如果克隆对 100 个数据页面进行修改,则只有这 100 个页面会存储在克隆卷上并标记为已用。父卷中其它 900 个未更改的页面由这两个集群共享。在这种情况下,将对父集群收取 1000 个页面的存储费用,而对克隆卷收取 100 个页面的存储费用。
如果您删除源卷,则克隆的存储费用包括它更改的 100 个页面,再加上原始卷中的 900 个共享页面,总共 1000 个页面。
创建 Amazon Aurora 克隆
您可以在与源 Aurora 数据库集群相同的AWS账户中创建克隆。为此,您可以使用 AWS Management Console 或 AWS CLI 并按照以下步骤进行操作。
若要允许其他 AWS 账户创建克隆或与其他 AWS 账户共享克隆,请遵照 使用 AWS RAM 与 Amazon Aurora 进行跨账户克隆 中的步骤。
以下过程介绍了如何使用 AWS Management Console 克隆 Aurora 数据库集群。
在含有一个 Aurora 数据库实例的 Aurora 数据库集群中使用 AWS Management Console 结果创建克隆。
这些说明适用于创建克隆的同一 AWS 账户所拥有的数据库集群。如果数据库集群由其他 AWS 账户拥有,请改为参阅 使用 AWS RAM 与 Amazon Aurora 进行跨账户克隆。
使用 AWS 创建 AWS Management Console 账户拥有的数据库集群的克隆
登录AWS Management Console并通过以下网址打开 Amazon RDS 控制台:https://console.aws.amazon.com/rds/
。 在导航窗格中,选择 Databases (数据库)。
从列表中选择您的 Aurora 数据库集群,从 Actions (操作) 中选择 Create clone (创建克隆)。
“创建克隆”页面打开后,您可以配置 Aurora 数据库集群克隆的设置、连接和其他选项。
-
对于数据库实例标识符,请输入您要为克隆的 Aurora 数据库集群拟定的名称。
对于 Aurora Serverless v1 数据库集群,请为容量类型选择预调配或无服务器。
仅当源 Aurora 数据库集群是 Aurora Serverless v1 数据库集群或者是加密的预置 Aurora 数据库集群时,您才可以选择 Serverless (无服务器)。
-
对于 Aurora Serverless v2 或预调配数据库集群,请为集群存储配置选择 Aurora I/O-Optimized 或 Aurora Standard。
有关更多信息,请参阅 Amazon Aurora 数据库集群的存储配置。
-
选择数据库实例大小或数据库集群容量:
-
对于预调配克隆,请选择数据库实例类。
您可以使用所提供的设置,也可以为克隆使用不同的数据库实例类。
-
对于 Aurora Serverless v1 或 Aurora Serverless v2 克隆,请选择容量设置。
您可以使用提供的设置,也可以根据您的克隆更改此类设置。
-
-
根据需要为克隆选择其它设置。要了解有关 Aurora 数据库集群和实例设置的更多信息,请参阅 创建 Amazon Aurora 数据库集群。
-
选择创建克隆。
克隆创建完成后,它将会与您的其他 Aurora 数据库集群一起列在控制台 Databases (数据库) 部分,而且其当前状态也会一起显示。当其状态为可用时,您的克隆即可以使用。
使用 AWS CLI 克隆 Aurora 数据库集群涉及用于创建克隆集群和向集群添加一个或多个数据库实例的单独步骤。
您使用的 restore-db-cluster-to-point-in-time
AWS CLI 命令将导致 Aurora 数据库集群具有与原始集群相同的存储数据,但没有 Aurora 数据库实例。在克隆可用之后,可以单独创建数据库实例。可以选择数据库实例的数量及其实例类别,来为克隆指定多于或者少于原始集群的计算容量。该过程的步骤如下所示:
-
使用 restore-db-cluster-to-point-in-time CLI 命令创建克隆。
-
使用 create-db-instance CLI 命令创建克隆的写入器数据库实例。
-
(可选)再运行一个 create-db-instance CLI 命令,用于将一个或多个读取器实例添加到克隆集群。使用读取器实例有助于提高克隆的高可用性和读取可扩展性。如果只要将克隆用于开发和测试,则可以跳过此步骤。
创建克隆
使用 restore-db-cluster-to-point-in-time
CLI 命令创建初始克隆集群。
从源 Aurora 数据库集群创建克隆
-
使用
restore-db-cluster-to-point-in-time
CLI 命令。为以下参数指定值。在这种典型情况下,克隆使用与原始集群相同的引擎模式:要么是预置,要么是 Aurora Serverless v1。-
--db-cluster-identifier
– 为克隆选择一个有意义的名称。使用 restore-db-cluster-to-point-in-time CLI 命令命名克隆。然后在 create-db-instance CLI 命令中传递克隆的名称。 -
--restore-type
– 使用copy-on-write
创建源数据库集群的克隆。如果没有此参数,restore-db-cluster-to-point-in-time
将还原 Aurora 数据库集群,而不会创建克隆。 -
--source-db-cluster-identifier
– 使用要克隆的源 Aurora 数据库集群的名称。 -
--use-latest-restorable-time
– 此值指向源数据库集群的最新可还原卷数据。使用它来创建克隆。
-
以下示例从名为 my-source-cluster
的集群创建一个名为 my-clone
的克隆。
对于 Linux、macOS 或 Unix:
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier
my-source-cluster
\ --db-cluster-identifiermy-clone
\ --restore-type copy-on-write \ --use-latest-restorable-time
对于 Windows:
aws rds restore-db-cluster-to-point-in-time ^ --source-db-cluster-identifier
my-source-cluster
^ --db-cluster-identifiermy-clone
^ --restore-type copy-on-write ^ --use-latest-restorable-time
该命令返回包含克隆详细信息的 JSON 对象。在尝试为您的克隆创建数据库实例之前,请检查以确保您的克隆数据库集群可用。有关更多信息,请参阅 检查状态并获取克隆的详细信息。
例如,假设您有一个名为 tpch100g
的集群需要克隆。下面的 Linux 示例创建了一个名为 tpch100g-clone
的克隆集群,并为该新集群创建了一个名为 tpch100g-clone-instance
的 Aurora Serverless v2 写入器实例和一个名为 tpch100g-clone-instance-2
的预置读取器实例。
有些参数并不需要提供,例如 --master-username
和 --master-user-password
。Aurora 会自动从原始集群中确定那些参数。您需要指定的是要使用的数据库引擎。因此,该示例测试新集群以确定要用于 --engine
参数的正确值。
此示例还在创建克隆集群时包括 --serverless-v2-scaling-configuration
选项。这样,即使原始集群未使用 Aurora Serverless v2,您也可以向克隆中添加 Aurora Serverless v2 实例。
$
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier tpch100g \ --db-cluster-identifier tpch100g-clone \ --serverless-v2-scaling-configuration MinCapacity=0.5
,MaxCapacity=16
\ --restore-type copy-on-write \ --use-latest-restorable-time$
aws rds describe-db-clusters \ --db-cluster-identifier tpch100g-clone \ --query '*[].[Engine]' \ --output textaurora-mysql
$
aws rds create-db-instance \ --db-instance-identifier tpch100g-clone-instance \ --db-cluster-identifier tpch100g-clone \ --db-instance-class db.serverless \ --engine aurora-mysql$
aws rds create-db-instance \ --db-instance-identifier tpch100g-clone-instance-2 \ --db-cluster-identifier tpch100g-clone \ --db-instance-class db.r6g.2xlarge \ --engine aurora-mysql
使用与源 Aurora 数据库集群不同的引擎模式创建克隆
-
此过程仅适用于支持 Aurora Serverless v1 的较旧引擎版本。假设您有一个 Aurora Serverless v1 集群,并且想要创建一个作为预置集群的克隆。在这种情况下,请使用
restore-db-cluster-to-point-in-time
CLI 命令,并指定与上一个示例中的参数值类似的值,另加以下附加参数:-
--engine-mode
– 此参数仅用于创建与源 Aurora 数据库集群属于不同引擎模式的克隆。此参数仅适用于支持 Aurora Serverless v1 的较旧引擎版本。选择与--engine-mode
一起传递的值,如下所示:-
使用
--engine-mode provisioned
从 Aurora Serverless 数据库集群创建预置 Aurora 数据库集群克隆。注意
如果您打算将 Aurora Serverless v2 与从 Aurora Serverless v1 中克隆的集群一起使用,则仍将克隆的引擎模式指定为
provisioned
。接着,您可以随后执行其它升级和迁移步骤。 -
使用
--engine-mode serverless
从预置 Aurora 数据库集群创建 Aurora Serverless v1 克隆。当您指定serverless
引擎模式时,您也可以选择--scaling-configuration
。
-
-
--scaling-configuration
–(可选)与--engine-mode serverless
一起使用以配置 Aurora Serverless v1 克隆的最小和最大容量。如果不使用此参数,Aurora 将使用数据库引擎的默认 Aurora Serverless v1 容量值创建 Aurora Serverless v1 克隆。
-
以下示例从名为 my-source-cluster
的 Aurora Serverless v1 数据库集群创建名为 my-clone
的预置克隆。
对于 Linux、macOS 或 Unix:
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier
my-source-cluster
\ --db-cluster-identifiermy-clone
\ --engine-mode provisioned \ --restore-type copy-on-write \ --use-latest-restorable-time
对于 Windows:
aws rds restore-db-cluster-to-point-in-time ^ --source-db-cluster-identifier
my-source-cluster
^ --db-cluster-identifiermy-clone
^ --engine-mode provisioned ^ --restore-type copy-on-write ^ --use-latest-restorable-time
这些命令返回包含创建数据库实例所需的克隆的详细信息的 JSON 对象。在克隆(空的 Aurora 数据库集群)的状态变为可用之前,您不能这样做。
注意
restore-db-cluster-to-point-in-time AWS CLI 命令仅还原数据库集群,而不还原该数据库集群的数据库实例。要为还原的数据库集群创建数据库实例,请运行 create-db-instance 命令。使用该命令,可以将还原的数据库集群的标识符指定为 --db-cluster-identifier
参数。只有在完成 restore-db-cluster-to-point-in-time
命令并且数据库集群可用后,您才能创建数据库实例。
假设您从一个 Aurora Serverless v1 集群开始,并打算将其迁移到 Aurora Serverless v2 集群。作为迁移的初始步骤,可以创建 Aurora Serverless v1 集群的预置克隆。有关完整过程,包括任何必需的版本升级,请参阅从 Aurora Serverless v1 集群升级到 Aurora Serverless v2。
检查状态并获取克隆的详细信息
可以使用以下命令来检查新创建的克隆集群的状态。
$
aws rds describe-db-clusters --db-cluster-identifier
my-clone
--query '*[].[Status]' --output text
或者,您可以使用下面的 AWS CLI 查询获取为您的克隆创建数据库实例所需的状态和其他值。
对于 Linux、macOS 或 Unix:
aws rds describe-db-clusters --db-cluster-identifier
my-clone
\ --query '*[].{Status:Status,Engine:Engine,EngineVersion:EngineVersion,EngineMode:EngineMode}'
对于 Windows:
aws rds describe-db-clusters --db-cluster-identifier
my-clone
^ --query "*[].{Status:Status,Engine:Engine,EngineVersion:EngineVersion,EngineMode:EngineMode}"
此查询返回类似于下述信息的输出:
[ { "Status": "available", "Engine": "aurora-mysql", "EngineVersion": "8.0.mysql_aurora.3.04.1", "EngineMode": "provisioned" } ]
为克隆创建 Aurora 数据库实例
使用 create-db-instance CLI 命令为您的 Aurora Serverless v2 或预调配克隆创建数据库实例。您不会为 Aurora Serverless v1 克隆创建数据库实例。
数据库实例从源数据库集群继承 --master-username
和 --master-user-password
属性。
以下示例为预调配克隆创建数据库实例。
对于 Linux、macOS 或 Unix:
aws rds create-db-instance \ --db-instance-identifier
my-new-db
\ --db-cluster-identifiermy-clone
\ --db-instance-classdb.r6g.2xlarge
\ --engine aurora-mysql
对于 Windows:
aws rds create-db-instance ^ --db-instance-identifier
my-new-db
^ --db-cluster-identifiermy-clone
^ --db-instance-classdb.r6g.2xlarge
^ --engine aurora-mysql
以下示例为克隆(此克隆使用支持 Aurora Serverless v2 的引擎版本)创建 Aurora Serverless v2 数据库实例。
对于 Linux、macOS 或 Unix:
aws rds create-db-instance \ --db-instance-identifier
my-new-db
\ --db-cluster-identifiermy-clone
\ --db-instance-class db.serverless \ --engine aurora-postgresql
对于 Windows:
aws rds create-db-instance ^ --db-instance-identifier
my-new-db
^ --db-cluster-identifiermy-clone
^ --db-instance-class db.serverless ^ --engine aurora-mysql
用于克隆的参数
下表总结了与 restore-db-cluster-to-point-in-time
一起用于克隆 Aurora 数据库集群的各种参数。
参数 | 描述 |
---|---|
|
使用要克隆的源 Aurora 数据库集群的名称。 |
|
使用 |
|
将 |
|
此值指向源数据库集群的最新可还原卷数据。使用它来创建克隆。 |
|
(支持 Aurora Serverless v2 的较新版本)使用此参数可配置 Aurora Serverless v2 克隆的最小和最大容量。如果未指定此参数,则在修改集群来添加此属性之前,无法在克隆集群中创建任何 Aurora Serverless v2 实例。 |
|
(仅限支持 Aurora Serverless v1 的较旧版本)使用此参数创建与源 Aurora 数据库集群类型不同的克隆,采用以下值之一:
|
|
(仅限支持 Aurora Serverless v1 的较旧版本)使用此参数可配置 Aurora Serverless v1 克隆的最小和最大容量。如果不指定此参数,Aurora 将使用数据库引擎的默认容量值创建克隆。 |
使用 Amazon Aurora 的跨 VPC 克隆
假设您要对原始集群和克隆群施加不同的网络访问控制。例如,使用克隆功能,您可以在不同 VPC 中创建生产 Aurora 集群的副本,以供开发和测试之用。或者,在从公有子网迁移到私有子网的过程中,您也可以创建克隆,用于增强数据库的安全性。
以下各节演示如何为克隆设置网络配置,使得原始集群和克隆集群都可以访问相同的 Aurora 存储节点,即使这些节点来自不同的子网或不同的 VPC,也可以访问。预先验证网络资源,可以避免在克隆过程中出现可能难以诊断的错误。
如果您不熟悉 Aurora 如何与 VPC、子网和数据库子网组交互,请先参阅 Amazon VPC 和 Amazon Aurora。您可以按照该部分中的教程,在 AWS 管理控制台中创建这些类型的资源,并了解这些资源如何组合在一起。
由于这些步骤涉及在 RDS 和 EC2 服务之间切换,因此示例使用 AWS 命令行界面命令,来帮助您了解如何自动执行此类操作并保存输出。
开始前的准备工作
在您开始设置跨 VPC 克隆之前,请确保具有以下资源:
-
用作克隆的源的 Aurora 数据库集群。如果这是您首次创建 Aurora 数据库集群,请参阅开始使用 Amazon Aurora 中的教程,使用 MySQL 或 PostgreSQL 数据库引擎设置集群。
-
第二个 VPC(如果您打算创建跨 VPC 克隆)。如果您没有可用于克隆的 VPC,请参阅教程:创建 VPC 以用于数据库集群(仅限 IPv4)或教程:创建 VPC 以用于数据库集群(双堆栈模式)。
收集有关网络环境的信息
使用跨 VPC 克隆时,原始集群与其克隆集群之间的网络环境可能会有很大不同。在创建克隆之前,请您收集并记录有关原始集群中使用的 VPC、子网、数据库子网组和可用区的信息。这样,您就可以尽可能减少出现问题的可能性。如果出现了网络问题,您无需中断任何故障排除活动即可搜索诊断信息。以下各个部分说明了收集这些类型信息的 CLI 示例。在创建克隆和进行任何故障排除时,您可以将详细信息保存为任意便于查阅的格式。
步骤 1:检查原始集群的可用区
在创建克隆之前,请核实原始集群将哪些可用区用于其存储。如 Amazon Aurora 存储和可靠性中所述,每个 Aurora 集群的存储都与三个且仅与三个可用区相关联。由于 Amazon Aurora 数据库集群利用了计算和存储分离的优势,因此无论在集群中具有多少个实例,此规则都适用。
例如,运行类似下文的 CLI 命令,将
替换为您自己的集群名称。以下示例生成按可用区名称的字母顺序排序的列表。my_cluster
aws rds describe-db-clusters \ --db-cluster-identifier
my_cluster
\ --query 'sort_by(*[].AvailabilityZones[].{Zone:@},&Zone)' \ --output text
以下示例说明了前述 describe-db-clusters
命令的示例输出。它表明 Aurora 集群的存储始终使用三个可用区。
us-east-1c
us-east-1d
us-east-1e
要在没有足够资源连接到这些可用区的网络环境中创建克隆集群,您必须创建与其中至少两个可用区关联的子网,然后创建包含这两个或三个子网的数据库子网组。下面的示例演示了如何操作。
步骤 2:检查原始集群的数据库子网组
如果您要为克隆集群使用与原始集群相同数量的子网,则可以从原始集群的数据库子网组中获取子网的数量。Aurora 数据库子网组至少包含两个子网,每个子网都与不同的可用区关联。记下子网与哪些可用区关联。
以下示例演示如何查找原始集群的数据库子网组,然后逆向推导出对应的可用区。将第一个命令中的
替换为您的集群名称。将第二个命令中的 my_cluster
替换为数据库子网组的名称。my_subnet
aws rds describe-db-clusters --db-cluster-identifier
my_cluster
\ --query '*[].DBSubnetGroup' --output text aws rds describe-db-subnet-groups --db-subnet-group-namemy_subnet_group
\ --query '*[].Subnets[].[SubnetAvailabilityZone.Name]' --output text
对于其数据库子网组包含两个子网的集群,示例输出可能类似于以下内容。在本例中,two-subnets
是创建数据库子网组时指定的名称。
two-subnets
us-east-1d
us-east-1c
对于数据库子网组包含三个子网的集群,输出可能类似于下文。
three-subnets
us-east-1f
us-east-1d
us-east-1c
步骤 3:检查原始集群的子网
如果您需要有关原始集群中子网的更多详细信息,请运行类似于下文的 AWS 命令行界面命令。您可以检查子网属性,例如 IP 地址范围、所有者等。这样,您就可以确定是使用同一个 VPC 中的不同子网,还是在不同的 VPC 中创建具有相似特性的子网。
查找您的 VPC 中所有可用子网的子网 ID。
aws ec2 describe-subnets --filters Name=vpc-id,Values=
my_vpc
\ --query '*[].[SubnetId]' --output text
查找在您的数据库子网组中所使用的那些子网。
aws rds describe-db-subnet-groups --db-subnet-group-name
my_subnet_group
\ --query '*[].Subnets[].[SubnetIdentifier]' --output text
然后在列表中指定要调查的子网,如以下命令所示。用您的子网名称替换
,依此类推。my_subnet_1
aws ec2 describe-subnets \ --subnet-ids '["
my_subnet_1
","my_subnet2
","my_subnet3
"]'
以下示例说明了此类 describe-subnets
命令的部分输出。输出显示了您可以查看的每个子网的一些重要属性,例如与其关联的可用区和所属的 VPC。
{
'Subnets': [
{
'AvailabilityZone': 'us-east-1d',
'AvailableIpAddressCount': 54,
'CidrBlock': '10.0.0.64/26',
'State': 'available',
'SubnetId': 'subnet-000a0bca00e0b0000',
'VpcId': 'vpc-3f3c3fc3333b3ffb3',
...
},
{
'AvailabilityZone': 'us-east-1c',
'AvailableIpAddressCount': 55,
'CidrBlock': '10.0.0.0/26',
'State': 'available',
'SubnetId': 'subnet-4b4dbfe4d4a4fd4c4',
'VpcId': 'vpc-3f3c3fc3333b3ffb3',
...
步骤 4:检查原始集群中数据库实例的可用区
您可以使用此过程来了解原始集群中用于数据库实例的可用区。这样,您就可以为克隆集群中的数据库实例设置完全相同的可用区。您还可以根据克隆集群用于生产环境还是开发和测试等,在克隆集群中增加或减少数据库实例的数量。
对于原始集群中的每个实例,运行类似于下文的命令。请确保该实例已完成创建,并且首先处于 Available
状态。将
替换为实例标识符。my_instance
aws rds describe-db-instances --db-instance-identifier
my_instance
\ --query '*[].AvailabilityZone' --output text
下面的示例显示了运行前述 describe-db-instances
命令的输出。Aurora 集群有四个数据库实例。因此,我们运行该命令四次,每次都替换为不同的数据库实例标识符。输出显示了这些数据库实例如何分布在最多三个可用区中。
us-east-1a
us-east-1c
us-east-1d
us-east-1a
创建克隆集群并向其添加数据库实例后,您可以在 create-db-instance
命令中指定这些相同的可用区名称。您可以采用这种做法来设置数据库实例,以便在新集群中配置与原始集群中完全相同的可用区。
第 5 步:检查可用于克隆集群的 VPC
如果您打算在与原始集群不同的 VPC 中创建克隆集群,则可以获取对您账户可用的 VPC ID 列表。如果您需要在与原始集群相同的 VPC 中创建任何额外的子网,也可以执行此步骤。运行命令创建子网时,您需要指定 VPC ID 作为参数。
要列出对您账户可用的所有 VPC,请运行以下 CLI 命令:
aws ec2 describe-vpcs --query '*[].[VpcId]' --output text
以下示例说明了前述 describe-vpcs
命令的示例输出。输出显示当前 AWS 账户中有四个 VPC,可以用作跨 VPC 克隆的源或目标。
vpc-fd111111
vpc-2222e2cd2a222f22e
vpc-33333333a33333d33
vpc-4ae4d4de4a4444dad
您可以将同一个 VPC 作为克隆集群的目标,也可以使用不同的 VPC。如果原始集群和克隆集群位于同一个 VPC 中,则可以为克隆集群重复使用相同的数据库子网组。您也可以创建不同的数据库子网组。例如,新的数据库子网组可能会使用私有子网,而原始集群的数据库子网组可能使用的是公有子网。如果您在不同的 VPC 中创建克隆集群,请确保新 VPC 中有足够的子网,并且这些子网与原始集群中的正确可用区相关联。
为克隆集群创建网络资源
如果在收集网络信息时,您发现克隆集群需要额外的网络资源,则可以先创建这些资源,然后再尝试设置克隆集群。例如,您可能需要创建更多子网、将子网与特定可用区关联或创建新数据库子网组。
步骤 1:为克隆集群创建子网
如果您需要为克隆集群创建新的子网,请运行类似下文的命令。在不同的 VPC 中创建克隆集群或者进行了其他网络更改(例如使用私有子网而非公有子网)时,您可能需要执行此操作。
AWS 会自动生成子网的 ID。将
替换为克隆集群的 VPC 的名称。为 my_vpc
--cidr-block
选项选择地址范围,允许范围内至少有 16 个 IP 地址。您可以包括要指定的任何其他属性。运行命令 aws ec2 create-subnet help
以查看所有选项。
aws ec2 create-subnet --vpc-id
my_vpc
\ --availability-zoneAZ_name
--cidr-blockIP_range
以下示例显示了新创建子网的一些重要属性。
{
'Subnet': {
'AvailabilityZone': 'us-east-1b',
'AvailableIpAddressCount': 59,
'CidrBlock': '10.0.0.64/26',
'State': 'available',
'SubnetId': 'subnet-44b4a44f4e44db444',
'VpcId': 'vpc-555fc5df555e555dc',
...
}
}
步骤 2:为克隆集群创建数据库子网组
如果您要在不同的 VPC 中创建克隆集群,或者使用同一 VPC 内的一组不同的子网,则您可以创建一个新的数据库子网组,然后在创建克隆集群时指定该子网组。
请确保您了解以下所有详细信息。您可从前面示例的输出中找到所有这些信息。
-
原始集群的 VPC。有关说明,请参阅 步骤 3:检查原始集群的子网。
-
克隆集群的 VPC(当您在不同的 VPC 中创建克隆集群时)。有关说明,请参阅 第 5 步:检查可用于克隆集群的 VPC。
-
与原始集群的 Aurora 存储相关联的三个可用区。有关说明,请参阅 步骤 1:检查原始集群的可用区。
-
与原始集群的数据库子网组关联的两个或三个可用区。有关说明,请参阅 步骤 2:检查原始集群的数据库子网组。
-
您打算用于克隆集群的 VPC 中所有子网的子网 ID 和关联可用区。使用与步骤 3:检查原始集群的子网中相同的
describe-subnets
命令,替换目标 VPC 的 VPC ID。
检查有多少个可用区既与原始集群的存储相关联,又与目标 VPC 中的子网相关联。要成功创建克隆集群,必须有两个或三个共同的可用区。如果共同可用区少于两个,请返回到步骤 1:为克隆集群创建子网。创建一个、两个或三个新的子网,这些子网关联到与原始集群存储相关联的可用区。
在目标 VPC 中选择子网,这些子网应关联到与原始集群中的 Aurora 存储关联的相同可用区。理想情况下,选择三个可用区。采用这种做法,克隆集群的数据库实例可以尽可能灵活地分布到多个可用区,从而实现计算资源的高可用性。
运行类似下文的命令来创建新的数据库子网组。替换为您在列表中的子网 ID。如果您使用环境变量指定子网 ID,请注意在括起 --subnet-ids
参数列表时,要保留 ID 两边的双引号。
aws rds create-db-subnet-group --db-subnet-group-name
my_subnet_group
\ --subnet-ids '["my_subnet_1
","my_subnet_2
","my_subnet3
"]' \ --db-subnet-group-description 'DB subnet group with 3 subnets for clone'
下面的示例显示了 create-db-subnet-group
命令的部分输出。
{
'DBSubnetGroup': {
'DBSubnetGroupName': 'my_subnet_group
',
'DBSubnetGroupDescription': 'DB subnet group with 3 subnets for clone',
'VpcId': 'vpc-555fc5df555e555dc',
'SubnetGroupStatus': 'Complete',
'Subnets': [
{
'SubnetIdentifier': 'my_subnet_1
',
'SubnetAvailabilityZone': {
'Name': 'us-east-1c'
},
'SubnetStatus': 'Active'
},
{
'SubnetIdentifier': 'my_subnet_2
',
'SubnetAvailabilityZone': {
'Name': 'us-east-1d'
},
'SubnetStatus': 'Active'
}
...
],
'SupportedNetworkTypes': [
'IPV4'
]
}
}
此时,您还没有实际创建克隆集群。您已创建所有相关的 VPC 和子网资源,这样在创建克隆集群时,您可以为 restore-db-cluster-to-point-in-time
和 create-db-instance
命令指定相应的参数。
使用新的网络设置创建 Aurora 克隆
在您确保 VPC、子网、可用区和子网组的配置正确且可供新集群使用时,就可以执行实际的克隆操作了。以下 CLI 示例重点介绍在设置克隆及其数据库实例时,您在命令中指定的选项,例如 --db-subnet-group-name
、--availability-zone
和 --vpc-security-group-ids
。
步骤 1:为克隆集群指定数据库子网组
创建克隆时,您可以通过指定数据库子网组来正确配置所有 VPC、子网和可用区设置。使用前面示例中的命令来验证进入数据库子网组的所有关系和映射。
例如,以下命令用于将原始集群克隆到克隆集群。在第一个示例中,源集群与两个子网关联,克隆集群与三个子网关联。第二个示例显示了相反的情况,即从具有三个子网的集群克隆到具有两个子网的集群。
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier cluster-with-3-subnets \ --db-cluster-identifier cluster-cloned-to-2-subnets \ --restore-type copy-on-write --use-latest-restorable-time \ --db-subnet-group-name two-subnets
如果您打算在克隆集群中使用 Aurora Serverless v2 实例,请在创建克隆时提供 --serverless-v2-scaling-configuration
选项,如下所示。这样做可以让您在克隆集群中创建数据库实例时使用 db.serverless
类。您也可以在以后修改克隆集群来添加此扩展配置属性。此示例中的容量数字允许集群中的每个 Serverless v2 实例在 2 到 32 个 Aurora 容量单位(ACU,Aurora Capacity Unit)之间扩展。有关 Aurora Serverless v2 功能以及如何选择容量范围的信息,请参阅使用 Aurora Serverless v2。
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier cluster-with-2-subnets \ --db-cluster-identifier cluster-cloned-to-3-subnets \ --restore-type copy-on-write --use-latest-restorable-time \ --db-subnet-group-name three-subnets \ --serverless-v2-scaling-configuration 'MinCapacity=2,MaxCapacity=32'
无论数据库实例使用多少个子网,源集群和克隆集群的 Aurora 存储都与三个可用区相关联。以下示例针对前面示例中的两个 restore-db-cluster-to-point-in-time
命令,列出了与源集群和克隆集群关联的可用区。
aws rds describe-db-clusters --db-cluster-identifier cluster-with-3-subnets \ --query 'sort_by(*[].AvailabilityZones[].{Zone:@},&Zone)' --output text
us-east-1c us-east-1d us-east-1f
aws rds describe-db-clusters --db-cluster-identifier cluster-cloned-to-2-subnets \ --query 'sort_by(*[].AvailabilityZones[].{Zone:@},&Zone)' --output textus-east-1c us-east-1d us-east-1f
aws rds describe-db-clusters --db-cluster-identifier cluster-with-2-subnets \ --query 'sort_by(*[].AvailabilityZones[].{Zone:@},&Zone)' --output textus-east-1a us-east-1c us-east-1d
aws rds describe-db-clusters --db-cluster-identifier cluster-cloned-to-3-subnets \ --query 'sort_by(*[].AvailabilityZones[].{Zone:@},&Zone)' --output textus-east-1a us-east-1c us-east-1d
由于每一对原始集群和克隆集群之间至少有两个可用区重叠,因此两个集群都可以访问相同的底层 Aurora 存储。
步骤 2:为克隆集群中的实例指定网络设置
在克隆集群中创建数据库实例时,默认情况下,它们会继承集群本身的数据库子网组。这样,Aurora 就会自动将每个实例分配到一个特定的子网,并在与该子网关联的可用区中创建实例。这种选择非常方便,尤其是对于开发和测试系统,因为在向克隆集群添加新实例时,您不必跟踪子网 ID 或可用区。
或者,您可以在为克隆集群创建 Aurora 数据库实例时指定可用区。您指定的可用区必须来自与克隆集群关联的一组可用区。如果您用于克隆集群的数据库子网组仅包含两个子网,则您只能从与这两个子网关联的可用区中进行选择。这种选择为高可用性系统提供了灵活性和韧性,因为您可以确保写入器实例和备用读取器实例位于不同的可用区中。或者,如果您向集群添加其他读取器,则可以确保它们分布在三个可用区中。这样,即使在极少的情况下可用区出现了故障,您在另外两个可用区中仍然有一个写入器实例和另一个读取器实例。
以下示例将预置的数据库实例添加到使用自定义数据库子网组的克隆 Aurora PostgreSQL 集群。
aws rds create-db-instance --db-cluster-identifier
my_aurora_postgresql_clone
\ --db-instance-identifiermy_postgres_instance
\ --db-subnet-group-namemy_new_subnet
\ --engine aurora-postgresql \ --db-instance-class db.t4g.medium
以下示例说明了此命令的部分输出。
{
'DBInstanceIdentifier': 'my_postgres_instance
',
'DBClusterIdentifier': 'my_aurora_postgresql_clone
',
'DBInstanceClass': 'db.t4g.medium',
'DBInstanceStatus': 'creating'
...
}
以下示例将 Aurora Serverless v2 数据库实例添加到使用自定义数据库子网组的 Aurora MySQL 克隆集群中。为了能够使用 Serverless v2 实例,请确保为 restore-db-cluster-to-point-in-time
命令指定 --serverless-v2-scaling-configuration
选项,如前面的示例所示。
aws rds create-db-instance --db-cluster-identifier
my_aurora_mysql_clone
\ --db-instance-identifiermy_mysql_instance
\ --db-subnet-group-namemy_other_new_subnet
\ --engine aurora-mysql \ --db-instance-class db.serverless
以下示例说明了此命令的部分输出。
{
'DBInstanceIdentifier': 'my_mysql_instance
',
'DBClusterIdentifier': 'my_aurora_mysql_clone
',
'DBInstanceClass': 'db.serverless',
'DBInstanceStatus': 'creating'
...
}
步骤 3:建立从客户端系统到克隆集群的连接
如果您已经从客户端系统连接到 Aurora 集群,则可能需要允许对新克隆集群使用相同类型的连接。例如,您可能从 Amazon Cloud9 实例或 EC2 实例连接到原始集群。要允许来自相同客户端系统或您在目标 VPC 中创建的新客户端系统的连接,请设置与 VPC 中等同的数据库子网组和 VPC 安全组。然后,在创建克隆集群时指定子网组和安全组。
以下示例设置 Aurora Serverless v2 克隆集群。该配置基于创建数据库集群时 --engine-mode provisioned
和 --serverless-v2-scaling-configuration
的组合,然后在集群中创建每个数据库实例使用 --db-instance-class db.serverless
。provisioned
引擎模式是默认模式,因此如果您首选该模式,可以省略该选项。
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier serverless-sql-postgres\ --db-cluster-identifier serverless-sql-postgres-clone \ --db-subnet-group-name 'default-vpc-1234' \ --vpc-security-group-ids 'sg-4567' \ --serverless-v2-scaling-configuration 'MinCapacity=0.5,MaxCapacity=16' \ --restore-type copy-on-write \ --use-latest-restorable-time
然后,在克隆集群中创建数据库实例时,请指定相同的 --db-subnet-group-name
选项。或者,您可以提供 --availability-zone
选项并指定与该子网组中子网关联的可用区之一。此可用区还必须是与原始集群关联的可用区之一。
aws rds create-db-instance \ --db-cluster-identifier serverless-sql-postgres-clone \ --db-instance-identifier serverless-sql-postgres-clone-instance \ --db-instance-class db.serverless \ --db-subnet-group-name 'default-vpc-987zyx654' \ --availability-zone 'us-east-1c' \ --engine aurora-postgresql
将集群从公有子网移动到私有子网
您可以使用克隆在公有子网和私有子网之间移动集群。在将应用程序部署到生产环境之前,要为其添加额外的安全层时,您可以执行此操作。在本示例中,在开始 Aurora 的克隆过程之前,您应该已经设置好私有子网和 NAT 网关。
对于涉及 Aurora 的步骤,您可以按照前面示例中的相同常规步骤操作,以便收集有关网络环境的信息和使用新的网络设置创建 Aurora 克隆。主要区别在于,即使您有映射到原始集群中所有可用区的公有子网,现在您也必须验证 Aurora 集群是否有足够的私有子网,以及这些子网是否与原始集群中用于 Aurora 存储的相同的所有可用区关联。与其他克隆应用场景类似,您可以为克隆生成数据库子网组,在子网组中包括与所需可用区关联的两个或三个私有子网。但是,如果您在数据库子网组中使用两个私有子网,则必须有第三个私有子网,该子网与原始集群中用于 Aurora 存储的第三个可用区相关联。
您可以查阅此清单,验证是否满足执行此类克隆操作的所有要求。
-
记录与原始集群关联的三个可用区。有关说明,请参阅 步骤 1:检查原始集群的可用区。
-
记录与原始集群的数据库子网组中公有子网关联的两个或三个可用区。有关说明,请参阅 步骤 3:检查原始集群的子网。
-
创建映射到与原始集群关联的全部三个可用区的私有子网。此外还需要完成与私有子网通信所需的任何其他联网设置,例如创建 NAT 网关。有关说明,请参阅《Amazon Virtual Private Cloud 用户指南》中的创建子网。
-
创建一个新数据库子网组,其中包含三个或两个私有子网,这些子网一开始就与可用区关联。有关说明,请参阅 步骤 2:为克隆集群创建数据库子网组。
满足所有先决条件后,您可以在创建克隆集群时暂停原始集群上的数据库活动,然后切换应用程序来使用克隆集群。在创建了克隆集群并确认可以连接到克隆集群、运行应用程序代码等之后,您可以停止使用原始集群。
创建跨 VPC 克隆的端到端示例
在与原始集群不同的 VPC 中创建克隆集群时,所使用的常规步骤与前面的示例相同。由于 VPC ID 是子网的属性,因此在运行任何 RDS CLI 命令时,您无需指定 VPC ID 作为参数。主要区别在于,您更可能需要创建新的子网,将新子网映射到特定可用区,创建 VPC 安全组和新的数据库子网组。如果这是您在该 VPC 中创建的第一个 Aurora 集群,就会完全是这种情况。
您可以查阅此清单,验证是否满足执行此类克隆操作的所有要求。
-
记录与原始集群关联的三个可用区。有关说明,请参阅 步骤 1:检查原始集群的可用区。
-
记录与原始集群的数据库子网组中子网关联的两个或三个可用区。有关说明,请参阅 步骤 2:检查原始集群的数据库子网组。
-
创建映射到与原始集群关联的全部三个可用区的子网。有关说明,请参阅 步骤 1:为克隆集群创建子网。
-
针对客户端系统、应用程序服务器等,执行与克隆集群中的数据库实例进行通信所需的任何其他联网设置,例如设置 VPC 安全组。有关说明,请参阅 使用安全组控制访问权限。
-
创建一个新数据库子网组,其中包含三个或两个子网,这些子网一开始就与可用区关联。有关说明,请参阅 步骤 2:为克隆集群创建数据库子网组。
满足所有先决条件后,您可以在创建克隆集群时暂停原始集群上的数据库活动,然后切换应用程序来使用克隆集群。在创建了克隆集群并确认可以连接到克隆集群、运行应用程序代码等之后,您可以考虑是保持原始集群和克隆集群继续运行,还是停止使用原始集群。
以下 Linux 示例说明了将 Aurora 数据库集群从一个 VPC 克隆到另一个 VPC 的 AWS 命令行界面操作顺序。命令输出中没有显示与示例无关的一些字段。
首先,我们检查源和目标 VPC 的 ID。在 VPC 元数据中,您在创建 VPC 时为其分配的描述性名称表示为标签。
$
aws ec2 describe-vpcs --query '*[].[VpcId,Tags]'[ [ 'vpc-0f0c0fc0000b0ffb0', [ { 'Key': 'Name', 'Value': 'clone-vpc-source' } ] ], [ 'vpc-9e99d9f99a999bd99', [ { 'Key': 'Name', 'Value': 'clone-vpc-dest' } ] ] ]
源 VPC 中已存在原始集群。要使用 Aurora 存储的同一组可用区来设置克隆集群,我们需要检查原始集群使用的可用区。
$
aws rds describe-db-clusters --db-cluster-identifier original-cluster \ --query 'sort_by(*[].AvailabilityZones[].{Zone:@},&Zone)' --output textus-east-1c us-east-1d us-east-1f
我们需要确保存在与原始集群使用的可用区相对应的子网:us-east-1c
、us-east-1d
和 us-east-1f
。
$
aws ec2 create-subnet --vpc-id vpc-9e99d9f99a999bd99 \ --availability-zone us-east-1c --cidr-block 10.0.0.128/28{ 'Subnet': { 'AvailabilityZone': 'us-east-1c', 'SubnetId': 'subnet-3333a33be3ef3e333', 'VpcId': 'vpc-9e99d9f99a999bd99', } }
$
aws ec2 create-subnet --vpc-id vpc-9e99d9f99a999bd99 \ --availability-zone us-east-1d --cidr-block 10.0.0.160/28{ 'Subnet': { 'AvailabilityZone': 'us-east-1d', 'SubnetId': 'subnet-4eeb444cd44b4d444', 'VpcId': 'vpc-9e99d9f99a999bd99', } }
$
aws ec2 create-subnet --vpc-id vpc-9e99d9f99a999bd99 \ --availability-zone us-east-1f --cidr-block 10.0.0.224/28{ 'Subnet': { 'AvailabilityZone': 'us-east-1f', 'SubnetId': 'subnet-66eea6666fb66d66c', 'VpcId': 'vpc-9e99d9f99a999bd99', } }
此示例确认了目标 VPC 中存在映射到所需可用区的子网。
aws ec2 describe-subnets --query 'sort_by(*[] | [?VpcId == `vpc-9e99d9f99a999bd99`] | [].{SubnetId:SubnetId,VpcId:VpcId,AvailabilityZone:AvailabilityZone}, &AvailabilityZone)' --output table
--------------------------------------------------------------------------- | DescribeSubnets | +------------------+----------------------------+-------------------------+ | AvailabilityZone | SubnetId | VpcId | +------------------+----------------------------+-------------------------+ | us-east-1a | subnet-000ff0e00000c0aea | vpc-9e99d9f99a999bd99 | | us-east-1b | subnet-1111d111111ca11b1 | vpc-9e99d9f99a999bd99 | | us-east-1c | subnet-3333a33be3ef3e333 | vpc-9e99d9f99a999bd99 | | us-east-1d | subnet-4eeb444cd44b4d444 | vpc-9e99d9f99a999bd99 | | us-east-1f | subnet-66eea6666fb66d66c | vpc-9e99d9f99a999bd99 | +------------------+----------------------------+-------------------------+
在 VPC 中创建 Aurora 数据库集群之前,您必须有一个数据库子网组,其子网映射到用于 Aurora 存储的可用区。创建常规集群时,您可以使用任意三个可用区的组合。克隆现有集群时,子网组必须与用于 Aurora 存储的三个可用区中的至少两个相匹配。
$
aws rds create-db-subnet-group \ --db-subnet-group-name subnet-group-in-other-vpc \ --subnet-ids '["subnet-3333a33be3ef3e333","subnet-4eeb444cd44b4d444","subnet-66eea6666fb66d66c"]' \ --db-subnet-group-description 'DB subnet group with 3 subnets: subnet-3333a33be3ef3e333,subnet-4eeb444cd44b4d444,subnet-66eea6666fb66d66c'{ 'DBSubnetGroup': { 'DBSubnetGroupName': 'subnet-group-in-other-vpc', 'DBSubnetGroupDescription': 'DB subnet group with 3 subnets: subnet-3333a33be3ef3e333,subnet-4eeb444cd44b4d444,subnet-66eea6666fb66d66c', 'VpcId': 'vpc-9e99d9f99a999bd99', 'SubnetGroupStatus': 'Complete', 'Subnets': [ { 'SubnetIdentifier': 'subnet-4eeb444cd44b4d444', 'SubnetAvailabilityZone': { 'Name': 'us-east-1d' } }, { 'SubnetIdentifier': 'subnet-3333a33be3ef3e333', 'SubnetAvailabilityZone': { 'Name': 'us-east-1c' } }, { 'SubnetIdentifier': 'subnet-66eea6666fb66d66c', 'SubnetAvailabilityZone': { 'Name': 'us-east-1f' } } ] } }
现在,子网和数据库子网组已准备就绪。以下示例说明了用于克隆集群的 restore-db-cluster-to-point-in-time
。--db-subnet-group-name
选项将克隆集群与正确的子网组相关联,这些子网映射到原始集群中正确的一组可用区。
$
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier original-cluster \ --db-cluster-identifier clone-in-other-vpc \ --restore-type copy-on-write --use-latest-restorable-time \ --db-subnet-group-name subnet-group-in-other-vpc{ 'DBClusterIdentifier': 'clone-in-other-vpc', 'DBSubnetGroup': 'subnet-group-in-other-vpc', 'Engine': 'aurora-postgresql', 'EngineVersion': '15.4', 'Status': 'creating', 'Endpoint': 'clone-in-other-vpc.cluster-c0abcdef.us-east-1.rds.amazonaws.com' }
以下示例确认克隆集群中的 Aurora 存储使用了与原始集群相同的一组可用区。
$
aws rds describe-db-clusters --db-cluster-identifier clone-in-other-vpc \ --query 'sort_by(*[].AvailabilityZones[].{Zone:@},&Zone)' --output textus-east-1c us-east-1d us-east-1f
此时,您可以为克隆集群创建数据库实例。在与每个实例关联的 VPC 安全组中,确保允许来自目标 VPC 中的 EC2 实例、应用程序服务器等所用的 IP 地址范围的连接。
使用 AWS RAM 与 Amazon Aurora 进行跨账户克隆
通过将 AWS Resource Access Manager(AWS RAM)与 Amazon Aurora 结合使用,您可以与另一个AWS账户或企业共享属于您的AWS账户的 Aurora 数据库集群和克隆。这种跨账户克隆比创建和恢复数据库快照快很多。您可以为您的 Aurora 数据库集群创建一个克隆并共享该克隆。或者,您可以与另一个AWS账户共享您的 Aurora 数据库集群,并让账户持有人创建克隆。方式的选择因使用案例而定。
如,您可能需要定期与组织的内部审计团队共享财务数据库的克隆。在这种情况下,您的审计团队对其使用的应用程序拥有自己的 AWS 账户。您可以授予审计团队的AWS账户访问 Aurora 数据库集群,并根据需要进行克隆的权限。
另一方面,如果外部供应商审核您的财务数据,您可能更愿意自己创建克隆。然后,您只允许外部供应商访问该克隆。
您还可以使用跨账户克隆来支持在同一AWS账户内进行克隆的许多相同用例,例如开发和测试。例如,您的企业可能会使用不同的 AWS 账户进行生产、开发、测试等。有关更多信息,请参阅“Aurora 克隆概述”。
因此,您可能希望与另一个AWS账户共享一个克隆或允许其他AWS账户创建您的 Aurora 数据库集群的克隆。无论哪种情况,请先使用 AWS RAM 来创建共享对象。有关在 AWS 账户之间共享 AWS 资源的完整信息,请参阅 AWS RAM 用户指南。
创建跨账户克隆需要来自拥有原始集群的 AWS 账户和创建克隆的 AWS 账户的操作。首先,原始集群拥有者修改集群以允许一个或多个其他账户克隆它。对于在不同的AWS组织中的任何账户,AWS会生成共享邀请。另一个账户必须接受邀请,然后才能继续。之后,每个授权账户便能克隆集群。在整个过程中,集群由其唯一的 Amazon Resource Name (ARN) 标识。
与在同一 AWS 账户内进行克隆一样,只有在源或克隆对数据进行更改时才使用额外的存储空间。届时将会收取存储费用。如果删除源集群,则会在剩余的克隆集群中平均分配存储成本。
跨账户克隆的限制
Aurora 跨账户克隆具有以下限制:
-
您无法跨 Aurora Serverless v1 账户克隆 AWS 集群。
-
您无法使用 AWS Management Console 来查看或接受共享资源的邀请。使用 AWS CLI、Amazon RDS API 或 AWS RAM 控制台查看和接受共享资源的邀请。
-
您仅可以从与您的 AWS 账户共享的克隆创建一个新克隆。
-
您无法共享已与您的AWS账户共享的资源(克隆或 Aurora 数据库集群)。
-
您最多可从任何单个 Aurora 数据库集群创建 15 个跨账户克隆。
-
这 15 个跨账户克隆中的每一个都必须由不同的 AWS 账户拥有。也就是说,任何AWS账户都只能创建一个集群的跨账户克隆。
-
克隆集群之后,为了对跨账户克隆实施限制,原始集群及其克隆应视为相同。不能在同一 AWS 账户内同时创建原始集群和克隆集群的跨账户克隆。原始集群及其任何克隆的跨账户克隆总数不能超过 15 个。
-
除非集群处于
ACTIVE
状态,否则您无法与其他AWS账户共享 Aurora 数据库集群。 -
您无法重命名与其他AWS账户共享的 Aurora 数据库集群。
-
您无法创建使用默认 RDS 密钥加密的集群的跨账户克隆。
-
对于从另一个 AWS 账户共享的加密 Aurora 数据库集群,您无法在 AWS 账户中创建非加密克隆。集群拥有者必须授予访问源集群的 AWS KMS key 的权限。但是,您可以在创建克隆时使用不同的密钥。
允许其他 AWS 账户克隆您的集群
要允许其他 AWS 账户克隆您拥有的集群,请使用 AWS RAM 设置共享权限。这样做还会向位于其他 AWS 组织中的所有其他账户发送邀请。
有关在 AWS RAM 控制台中共享您拥有的资源的过程,请参阅 AWS RAM 用户指南中的共享您拥有的资源。
向其他 AWS 账户授予克隆集群的权限
如果您共享的集群已加密,则您还可以共享集群的 AWS KMS key。您可以允许一个 AWS 账户中的 AWS Identity and Access Management (IAM) 用户或角色使用其他账户中的 KMS 密钥。
为此,您首先通过 AWS KMS 将外部账户(根用户)添加到 KMS 密钥的密钥策略中。您无需将单个用户或角色添加到密钥策略,只需添加拥有这些用户或角色的外部账户。您只能共享您创建的 KMS 密钥,而不能共享默认 RDS 服务密钥。有关 KMS 密钥的访问控制的信息,请参阅 AWS KMS 的身份验证和访问控制。
授予克隆您的集群的权限
登录AWS Management Console并通过以下网址打开 Amazon RDS 控制台:https://console.aws.amazon.com/rds/
。 -
在导航窗格中,选择 Databases (数据库)。
-
选择要共享的数据库集群以查看其 Details (详细信息) 页面,并选择 Connectivity & security (连接和安全性) 选项卡。
-
在 与其他 AWS 账户共享数据库集群 部分中,输入要允许克隆此集群的 AWS 账户的数字账户 ID。对于同一组织中的账户 ID,您可以开始在框中键入,然后从菜单中选择。
重要
在某些情况下,您可能需要使用一个不在您的账户所在的 AWS 组织中的账户来克隆集群。在这些情况下,出于安全原因,控制台不会报告谁拥有账户 ID 或该账户是否存在。
请小心输入不在您的 AWS 账户所在的 AWS 组织中的账号。立即验证您是否与目标账户共享。
-
在确认页面上,验证您指定的账户 ID 是否正确。在确认框中输入
share
以进行确认。在 Details (详细信息) 页面上,Accounts that this DB cluster is shared with (此数据库集群与之共享的账户) 下显示一个条目,该条目显示指定的AWS账户 ID。Status (状态) 列最初显示 Pending (待处理) 状态。
-
联系另一个 AWS 账户的拥有者,或者如果您同时拥有这两个账户,则登录到该账户。指示其他账户的拥有者接受共享邀请并克隆数据库集群,如下所述。
授予克隆您的集群的权限
-
收集所需参数的信息。您需要集群的 ARN 和其他 AWS 账户的数字 ID。
-
运行 AWS RAM CLI 命令
create-resource-share
。对于 Linux、macOS 或 Unix:
aws ram create-resource-share --name
descriptive_name
\ --regionregion
\ --resource-arnscluster_arn
\ --principalsother_account_ids
对于 Windows:
aws ram create-resource-share --name
descriptive_name
^ --regionregion
^ --resource-arnscluster_arn
^ --principalsother_account_ids
要包含
--principals
参数的多个账户 ID,请用空格将各个 ID 分隔开。要指定允许的账户 ID 是否能位于 AWS 组织外部,请包含--allow-external-principals
的--no-allow-external-principals
或create-resource-share
参数。
授予克隆您的集群的权限
-
收集所需参数的信息。您需要集群的 ARN 和其他 AWS 账户的数字 ID。
-
调用 AWS RAM API 操作 CreateResourceShare,并指定以下值:
-
指定一个或多个AWS账户的账户 ID 作为
principals
参数。 -
指定一个或多个 Aurora 数据库集群的 ARN 作为
resourceArns
参数。 -
通过包含
allowExternalPrincipals
参数的布尔值来指定允许的账户 ID 是否能位于您的 AWS 企业外部。
-
重新创建使用默认 RDS 密钥的集群
如果您计划共享的加密集群使用默认 RDS 密钥,请确保重新创建集群。为此,请为数据库集群创建手动快照,使用 AWS KMS key,然后将集群还原到新集群。然后共享新集群。要执行此过程,请按以下步骤进行操作。
重新创建使用默认 RDS 密钥的加密集群
登录AWS Management Console并通过以下网址打开 Amazon RDS 控制台:https://console.aws.amazon.com/rds/
。 -
在导航窗格中,选择 Snapshots (快照)。
-
选择您的快照。
-
对于 Actions (操作),选择 Copy Snapshot (复制快照),然后选择 Enable encryption (启用加密)。
-
对于 AWS KMS key,选择要使用的新加密密钥。
-
还原复制的快照。为此,请按照 中的过程操作从数据库集群快照还原 新数据库实例使用新的加密密钥。
-
(可选)如果您不再需要旧的数据库集群,请将其删除。为此,请按照 中的过程操作删除数据库集群快照 在这样做之前,请确认您的新集群拥有所有必要的数据,并且您的应用程序能够成功地访问该数据。
检查是否与其他AWS账户共享您拥有的集群
您可以检查其他用户是否有权共享集群。这样做可以帮助您了解集群是否正在接近跨账户克隆的最大数量限制。
有关使用 AWS RAM 控制台共享资源的过程,请参阅 AWS RAM 用户指南中的共享您拥有的资源。
要查明您拥有的集群是否与其他AWS账户共享
-
调用 AWS RAM CLI 命令
list-principals
,将账户 ID 用作资源拥有者,并将集群 ARN 用作资源 ARN。可使用以下命令来查看所有共享。结果指示允许哪些 AWS 账户克隆集群。aws ram list-principals \ --resource-arns
your_cluster_arn
\ --principalsyour_aws_id
要查明您拥有的集群是否与其他AWS账户共享
-
调用 AWS RAM API 操作 ListPrincipals。将账户 ID 用作资源拥有者,并将集群 ARN 用作资源 ARN。
克隆另一个AWS账户拥有的集群
要克隆另一个 AWS 账户拥有的集群,请使用 AWS RAM 获取创建克隆的权限。在获得必需权限后,您可以使用克隆 Aurora 集群的标准过程。
您还可以检查您拥有的集群是否为其他 AWS 账户拥有的集群的克隆。
有关在 AWS RAM 控制台中使用其他账户拥有的资源的过程,请参阅 AWS RAM 用户指南中的访问与您共享的资源。
查看克隆其他AWS账户拥有的集群的邀请
要处理克隆其他 AWS 组织中的 AWS 账户拥有的集群的邀请,请使用 AWS CLI、AWS RAM 控制台或 AWS RAM API。目前,您无法使用 Amazon RDS 控制台执行此过程。
有关在 AWS RAM 控制台中处理邀请的过程,请参阅 AWS RAM 用户指南中的访问与您共享的资源。
查看克隆其他AWS账户拥有的集群的邀请
-
运行 AWS RAM CLI 命令
get-resource-share-invitations
。aws ram get-resource-share-invitations --region
region_name
上述命令的结果显示所有克隆集群的邀请,包括您已接受或拒绝的任何邀请。
-
(可选)筛选列表,以便仅查看需要您执行操作的邀请。为此,请添加参数
--query 'resourceShareInvitations[?status==`PENDING`]'
。
查看克隆其他AWS账户拥有的集群的邀请
-
调用 AWS RAM API 操作
GetResourceShareInvitations
。此操作返回所有此类邀请,包括您已接受或拒绝的任何邀请。 -
(可选)通过在
resourceShareAssociations
返回字段中检查status
值PENDING
,仅查找需要您执行操作的邀请。
接受共享其他 AWS 账户拥有的集群的邀请
您可以接受共享其他 AWS 组织中的其他 AWS 账户拥有的集群的邀请。要处理这些邀请,请使用 AWS CLI、AWS RAM 和 RDS API 或 AWS RAM 控制台。目前,您无法使用 RDS 控制台执行此过程。
有关在 AWS RAM 控制台中处理邀请的过程,请参阅 AWS RAM 用户指南中的访问与您共享的资源。
接受共享其他AWS账户的集群的邀请
-
通过运行 AWS RAM CLI 命令
get-resource-share-invitations
查找邀请 ARN,如上所示。 -
通过调用 AWS RAM CLI 命令
accept-resource-share-invitation
接受邀请,如下所示。对于 Linux、macOS 或 Unix:
aws ram accept-resource-share-invitation \ --resource-share-invitation-arn
invitation_arn
\ --regionregion
对于 Windows:
aws ram accept-resource-share-invitation ^ --resource-share-invitation-arn
invitation_arn
^ --regionregion
接受共享他人集群的邀请
-
通过调用 AWS RAM API 操作
GetResourceShareInvitations
查找邀请 ARN,如上所示。 -
将 ARN 作为
resourceShareInvitationArn
参数传递到 RDS API 操作 AcceptResourceShareInvitation。
克隆另一个AWS账户拥有的 Aurora 集群
接受来自拥有数据库集群的 AWS 账户的邀请后(如上所示),您可以克隆集群。
克隆另一个AWS账户拥有的 Aurora 集群
登录AWS Management Console并通过以下网址打开 Amazon RDS 控制台:https://console.aws.amazon.com/rds/
。 -
在导航窗格中,选择 Databases (数据库)。
在数据库列表的顶部,您应看到一个或多个 Role (角色) 值为
Shared from account #
的项。出于安全原因,您只能看到有关原始集群的有限信息。您可以看到的属性是数据库引擎和版本等属性,这些属性在克隆的集群中必须相同。account_id
-
选择您打算克隆的集群。
-
对于 Actions (操作),选择 Create clone (创建克隆)。
-
按照控制台中的过程进行操作以完成对克隆集群的设置。
-
根据需要,为克隆的集群启用加密。如果要克隆的集群已加密,则必须为克隆的集群启用加密。与您共享集群的 AWS 账户还必须共享用于加密集群的 KMS 密钥。您可以使用相同的 KMS 密钥来加密克隆,也可以使用您自己的 KMS 密钥。无法为使用原定设置 KMS 密钥加密的集群创建跨账户克隆。
拥有加密密钥的账户必须通过使用密钥策略来向目标账户授予密钥的使用权限。此过程类似于共享加密快照的方式,使用密钥策略来向目标账户授予密钥的使用权限。
克隆另一个AWS账户拥有的 Aurora 集群
-
接受来自拥有数据库集群的 AWS 账户的邀请,如上所示。
-
通过在 RDS CLI 命令
source-db-cluster-identifier
的restore-db-cluster-to-point-in-time
参数中指定源集群的完整 ARN 来克隆集群,如下所示。如果未共享作为
source-db-cluster-identifier
传递的 ARN,则返回相同的错误,就像指定的集群不存在一样。对于 Linux、macOS 或 Unix:
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier=arn:aws:rds:
arn_details
\ --db-cluster-identifier=new_cluster_id
\ --restore-type=copy-on-write \ --use-latest-restorable-time对于 Windows:
aws rds restore-db-cluster-to-point-in-time ^ --source-db-cluster-identifier=arn:aws:rds:
arn_details
^ --db-cluster-identifier=new_cluster_id
^ --restore-type=copy-on-write ^ --use-latest-restorable-time -
如果要克隆的集群已加密,请通过包含
kms-key-id
参数来加密克隆的集群。此kms-key-id
值可以是用于加密原始数据库集群的值,也可以是您自己的 KMS 密钥。您的账户必须具有使用该加密密钥的权限。对于 Linux、macOS 或 Unix:
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier=arn:aws:rds:
arn_details
\ --db-cluster-identifier=new_cluster_id
\ --restore-type=copy-on-write \ --use-latest-restorable-time \ --kms-key-id=arn:aws:kms:arn_details
对于 Windows:
aws rds restore-db-cluster-to-point-in-time ^ --source-db-cluster-identifier=arn:aws:rds:
arn_details
^ --db-cluster-identifier=new_cluster_id
^ --restore-type=copy-on-write ^ --use-latest-restorable-time ^ --kms-key-id=arn:aws:kms:arn_details
拥有加密密钥的账户必须通过使用密钥策略来向目标账户授予密钥的使用权限。此过程类似于共享加密快照的方式,使用密钥策略来向目标账户授予密钥的使用权限。下面是密钥策略的示例。
{ "Id": "key-policy-1", "Version": "2012-10-17", "Statement": [ { "Sid": "Allow use of the key", "Effect": "Allow", "Principal": {"AWS": [ "arn:aws:iam::
account_id
:user/KeyUser", "arn:aws:iam::account_id
:root" ]}, "Action": [ "kms:CreateGrant", "kms:Encrypt", "kms:Decrypt", "kms:ReEncrypt*", "kms:GenerateDataKey*", "kms:DescribeKey" ], "Resource": "*" }, { "Sid": "Allow attachment of persistent resources", "Effect": "Allow", "Principal": {"AWS": [ "arn:aws:iam::account_id
:user/KeyUser", "arn:aws:iam::account_id
:root" ]}, "Action": [ "kms:CreateGrant", "kms:ListGrants", "kms:RevokeGrant" ], "Resource": "*", "Condition": {"Bool": {"kms:GrantIsForAWSResource": true}} } ] }
注意
restore-db-cluster-to-point-in-time AWS CLI 命令仅还原数据库集群,而不还原该数据库集群的数据库实例。要为恢复的数据库集群创建数据库实例,请调用 create-db-instance 命令。在 --db-cluster-identifier
中指定恢复的数据库集群的标识符。
只有在完成 restore-db-cluster-to-point-in-time
命令并且数据库集群可用后,您才能创建数据库实例。
克隆另一个AWS账户拥有的 Aurora 集群
-
接受来自拥有数据库集群的 AWS 账户的邀请,如上所示。
-
通过在 RDS API 操作
SourceDBClusterIdentifier
的RestoreDBClusterToPointInTime
参数中指定源集群的完整 ARN 来克隆集群。如果未共享作为
SourceDBClusterIdentifier
传递的 ARN,则返回相同的错误,就像指定的集群不存在一样。 -
如果要克隆的集群已加密,请包含
KmsKeyId
参数以加密克隆的集群。此kms-key-id
值可以是用于加密原始数据库集群的值,也可以是您自己的 KMS 密钥。您的账户必须具有使用该加密密钥的权限。在克隆卷时,目标账户必须具有使用用于加密源集群的加密密钥的权限。Aurora 使用
KmsKeyId
中指定的加密密钥对新的克隆集群进行加密。拥有加密密钥的账户必须通过使用密钥策略来向目标账户授予密钥的使用权限。此过程类似于共享加密快照的方式,使用密钥策略来向目标账户授予密钥的使用权限。下面是密钥策略的示例。
{ "Id": "key-policy-1", "Version": "2012-10-17", "Statement": [ { "Sid": "Allow use of the key", "Effect": "Allow", "Principal": {"AWS": [ "arn:aws:iam::
account_id
:user/KeyUser", "arn:aws:iam::account_id
:root" ]}, "Action": [ "kms:CreateGrant", "kms:Encrypt", "kms:Decrypt", "kms:ReEncrypt*", "kms:GenerateDataKey*", "kms:DescribeKey" ], "Resource": "*" }, { "Sid": "Allow attachment of persistent resources", "Effect": "Allow", "Principal": {"AWS": [ "arn:aws:iam::account_id
:user/KeyUser", "arn:aws:iam::account_id
:root" ]}, "Action": [ "kms:CreateGrant", "kms:ListGrants", "kms:RevokeGrant" ], "Resource": "*", "Condition": {"Bool": {"kms:GrantIsForAWSResource": true}} } ] }
注意
RestoreDBClusterToPointInTime RDS API 操作仅还原数据库集群,而不还原该数据库集群的数据库实例。要为恢复的数据库集群创建数据库实例,请调用 CreateDBInstance RDS API 操作。在 DBClusterIdentifier
中指定恢复的数据库集群的标识符。只有在完成 RestoreDBClusterToPointInTime
操作并且数据库集群可用后,您才能创建数据库实例。
检查数据库集群是否为跨账户克隆
DBClusters
对象标识每个集群是否是跨账户克隆。在运行 RDS CLI 命令 include-shared
时,可使用 describe-db-clusters
选项查看您有权克隆的集群。但是,您看不到此类集群的大部分配置详细信息。
检查数据库集群是否为跨账户克隆
-
调用 RDS CLI 命令
describe-db-clusters
。以下示例说明实际或潜在的跨账户克隆数据库集群在
describe-db-clusters
输出中的显示方式。对于您的 AWS 账户现在拥有的集群,CrossAccountClone
字段指示集群是否为另一个 AWS 账户拥有的数据库集群的克隆。在某些情况下,条目具有的 AWS 账号可能与您在 AWS 字段中的
DBClusterArn
账号不同。在此情况下,该条目表示由其他 AWS 账户拥有且可克隆的集群。此类条目仅具有DBClusterArn
字段。在创建克隆的集群时,指定与原始集群中相同的StorageEncrypted
、Engine
和EngineVersion
值。$aws rds describe-db-clusters --include-shared --region us-east-1 { "DBClusters": [ { "EarliestRestorableTime": "2023-02-01T21:17:54.106Z", "Engine": "aurora-mysql", "EngineVersion": "8.0.mysql_aurora.3.02.0", "CrossAccountClone": false, ... }, { "EarliestRestorableTime": "2023-02-09T16:01:07.398Z", "Engine": "aurora-mysql", "EngineVersion": "8.0.mysql_aurora.3.02.0", "CrossAccountClone": true, ... }, { "StorageEncrypted": false, "DBClusterArn": "arn:aws:rds:us-east-1:12345678:cluster:cluster-abcdefgh", "Engine": "aurora-mysql", "EngineVersion": "8.0.mysql_aurora.3.02.0 ] }
检查数据库集群是否为跨账户克隆
-
调用 RDS API 操作 DescribeDBClusters。
对于您的 AWS 账户现在拥有的集群,
CrossAccountClone
字段指示集群是否为另一个 AWS 账户拥有的数据库集群的克隆。在 AWS 字段中具有其他DBClusterArn
账号的条目表示其他 AWS 账户拥有且可克隆的集群。这些条目仅具有DBClusterArn
字段。在创建克隆的集群时,指定与原始集群中相同的StorageEncrypted
、Engine
和EngineVersion
值。以下示例显示一个返回值,该值说明了实际和潜在的克隆的集群。
{ "DBClusters": [ { "EarliestRestorableTime": "2023-02-01T21:17:54.106Z", "Engine": "aurora-mysql", "EngineVersion": "8.0.mysql_aurora.3.02.0", "CrossAccountClone": false, ... }, { "EarliestRestorableTime": "2023-02-09T16:01:07.398Z", "Engine": "aurora-mysql", "EngineVersion": "8.0.mysql_aurora.3.02.0", "CrossAccountClone": true, ... }, { "StorageEncrypted": false, "DBClusterArn": "arn:aws:rds:us-east-1:12345678:cluster:cluster-abcdefgh", "Engine": "aurora-mysql", "EngineVersion": "8.0.mysql_aurora.3.02.0" } ] }