New resource: aws_db_instance_automated_backups_replication

.changelog/23759.txt

@@ -0,0 +1,3 @@
+```release-note:new-resource
+aws_db_instance_automated_backups_replication
+```

internal/provider/provider.go

@@ -1659,25 +1659,26 @@ func Provider() *schema.Provider {
 			"aws_ram_resource_share":          ram.ResourceResourceShare(),
 			"aws_ram_resource_share_accepter": ram.ResourceResourceShareAccepter(),
 
-			"aws_db_cluster_snapshot":           rds.ResourceClusterSnapshot(),
-			"aws_db_event_subscription":         rds.ResourceEventSubscription(),
-			"aws_db_instance":                   rds.ResourceInstance(),
-			"aws_db_instance_role_association":  rds.ResourceInstanceRoleAssociation(),
-			"aws_db_option_group":               rds.ResourceOptionGroup(),
-			"aws_db_parameter_group":            rds.ResourceParameterGroup(),
-			"aws_db_proxy":                      rds.ResourceProxy(),
-			"aws_db_proxy_default_target_group": rds.ResourceProxyDefaultTargetGroup(),
-			"aws_db_proxy_endpoint":             rds.ResourceProxyEndpoint(),
-			"aws_db_proxy_target":               rds.ResourceProxyTarget(),
-			"aws_db_security_group":             rds.ResourceSecurityGroup(),
-			"aws_db_snapshot":                   rds.ResourceSnapshot(),
-			"aws_db_subnet_group":               rds.ResourceSubnetGroup(),
-			"aws_rds_cluster":                   rds.ResourceCluster(),
-			"aws_rds_cluster_endpoint":          rds.ResourceClusterEndpoint(),
-			"aws_rds_cluster_instance":          rds.ResourceClusterInstance(),
-			"aws_rds_cluster_parameter_group":   rds.ResourceClusterParameterGroup(),
-			"aws_rds_cluster_role_association":  rds.ResourceClusterRoleAssociation(),
-			"aws_rds_global_cluster":            rds.ResourceGlobalCluster(),
+			"aws_db_cluster_snapshot":                       rds.ResourceClusterSnapshot(),
+			"aws_db_event_subscription":                     rds.ResourceEventSubscription(),
+			"aws_db_instance":                               rds.ResourceInstance(),
+			"aws_db_instance_automated_backups_replication": rds.ResourceInstanceAutomatedBackupsReplication(),
+			"aws_db_instance_role_association":              rds.ResourceInstanceRoleAssociation(),
+			"aws_db_option_group":                           rds.ResourceOptionGroup(),
+			"aws_db_parameter_group":                        rds.ResourceParameterGroup(),
+			"aws_db_proxy":                                  rds.ResourceProxy(),
+			"aws_db_proxy_default_target_group":             rds.ResourceProxyDefaultTargetGroup(),
+			"aws_db_proxy_endpoint":                         rds.ResourceProxyEndpoint(),
+			"aws_db_proxy_target":                           rds.ResourceProxyTarget(),
+			"aws_db_security_group":                         rds.ResourceSecurityGroup(),
+			"aws_db_snapshot":                               rds.ResourceSnapshot(),
+			"aws_db_subnet_group":                           rds.ResourceSubnetGroup(),
+			"aws_rds_cluster":                               rds.ResourceCluster(),
+			"aws_rds_cluster_endpoint":                      rds.ResourceClusterEndpoint(),
+			"aws_rds_cluster_instance":                      rds.ResourceClusterInstance(),
+			"aws_rds_cluster_parameter_group":               rds.ResourceClusterParameterGroup(),
+			"aws_rds_cluster_role_association":              rds.ResourceClusterRoleAssociation(),
+			"aws_rds_global_cluster":                        rds.ResourceGlobalCluster(),
 
 			"aws_redshift_cluster":                       redshift.ResourceCluster(),
 			"aws_redshift_event_subscription":            redshift.ResourceEventSubscription(),

internal/service/rds/consts.go

@@ -37,6 +37,12 @@ const (
 	InstanceStatusStorageOptimization           = "storage-optimization"
 )
 
+const (
+	InstanceAutomatedBackupStatusPending     = "pending"
+	InstanceAutomatedBackupStatusReplicating = "replicating"
+	InstanceAutomatedBackupStatusRetained    = "retained"
+)
+
 const (
 	EventSubscriptionStatusActive    = "active"
 	EventSubscriptionStatusCreating  = "creating"

internal/service/rds/find.go

@@ -189,3 +189,81 @@ func FindEventSubscriptionByID(conn *rds.RDS, id string) (*rds.EventSubscription
 
 	return output.EventSubscriptionsList[0], nil
 }
+
+func FindDBInstanceAutomatedBackupByARN(conn *rds.RDS, arn string) (*rds.DBInstanceAutomatedBackup, error) {
+	input := &rds.DescribeDBInstanceAutomatedBackupsInput{
+		DBInstanceAutomatedBackupsArn: aws.String(arn),
+	}
+
+	output, err := findDBInstanceAutomatedBackup(conn, input)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if status := aws.StringValue(output.Status); status == InstanceAutomatedBackupStatusRetained {
+		// If the automated backup is retained, the replication is stopped.
+		return nil, &resource.NotFoundError{
+			Message:     status,
+			LastRequest: input,
+		}
+	}
+
+	// Eventual consistency check.
+	if aws.StringValue(output.DBInstanceAutomatedBackupsArn) != arn {
+		return nil, &resource.NotFoundError{
+			LastRequest: input,
+		}
+	}
+
+	return output, nil
+}
+
+func findDBInstanceAutomatedBackup(conn *rds.RDS, input *rds.DescribeDBInstanceAutomatedBackupsInput) (*rds.DBInstanceAutomatedBackup, error) {
+	output, err := findDBInstanceAutomatedBackups(conn, input)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if len(output) == 0 || output[0] == nil {
+		return nil, tfresource.NewEmptyResultError(input)
+	}
+
+	if count := len(output); count > 1 {
+		return nil, tfresource.NewTooManyResultsError(count, input)
+	}
+
+	return output[0], nil
+}
+
+func findDBInstanceAutomatedBackups(conn *rds.RDS, input *rds.DescribeDBInstanceAutomatedBackupsInput) ([]*rds.DBInstanceAutomatedBackup, error) {
+	var output []*rds.DBInstanceAutomatedBackup
+
+	err := conn.DescribeDBInstanceAutomatedBackupsPages(input, func(page *rds.DescribeDBInstanceAutomatedBackupsOutput, lastPage bool) bool {
+		if page == nil {
+			return !lastPage
+		}
+
+		for _, v := range page.DBInstanceAutomatedBackups {
+			if v != nil {
+				output = append(output, v)
+			}
+		}
+
+		return !lastPage
+	})
+
+	if tfawserr.ErrCodeEquals(err, rds.ErrCodeDBInstanceAutomatedBackupNotFoundFault) {
+		return nil, &resource.NotFoundError{
+			LastError:   err,
+			LastRequest: input,
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return output, nil
+}

internal/service/rds/instance_automated_backups_replication.go

@@ -0,0 +1,149 @@
+package rds
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/arn"
+	"github.com/aws/aws-sdk-go/service/rds"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-provider-aws/internal/conns"
+	"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
+	"github.com/hashicorp/terraform-provider-aws/internal/verify"
+)
+
+func ResourceInstanceAutomatedBackupsReplication() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceInstanceAutomatedBackupsReplicationCreate,
+		Read:   resourceInstanceAutomatedBackupsReplicationRead,
+		Delete: resourceInstanceAutomatedBackupsReplicationDelete,
+
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"kms_key_id": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				Computed:     true,
+				ForceNew:     true,
+				ValidateFunc: verify.ValidARN,
+			},
+			"pre_signed_url": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"retention_period": {
+				Type:     schema.TypeInt,
+				ForceNew: true,
+				Optional: true,
+				Default:  7,
+			},
+			"source_db_instance_arn": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: verify.ValidARN,
+			},
+		},
+	}
+}
+
+func resourceInstanceAutomatedBackupsReplicationCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*conns.AWSClient).RDSConn
+
+	input := &rds.StartDBInstanceAutomatedBackupsReplicationInput{
+		BackupRetentionPeriod: aws.Int64(int64(d.Get("retention_period").(int))),
+		SourceDBInstanceArn:   aws.String(d.Get("source_db_instance_arn").(string)),
+	}
+
+	if v, ok := d.GetOk("kms_key_id"); ok {
+		input.KmsKeyId = aws.String(v.(string))
+	}
+
+	if v, ok := d.GetOk("pre_signed_url"); ok {
+		input.PreSignedUrl = aws.String(v.(string))
+	}
+
+	log.Printf("[DEBUG] Starting RDS instance automated backups replication: %s", input)
+	output, err := conn.StartDBInstanceAutomatedBackupsReplication(input)
+
+	if err != nil {
+		return fmt.Errorf("error starting RDS instance automated backups replication: %w", err)
+	}
+
+	d.SetId(aws.StringValue(output.DBInstanceAutomatedBackup.DBInstanceAutomatedBackupsArn))
+
+	if _, err := waitDBInstanceAutomatedBackupCreated(conn, d.Id(), d.Timeout(schema.TimeoutCreate)); err != nil {
+		return fmt.Errorf("error waiting for DB instance automated backup (%s) create: %w", d.Id(), err)
+	}
+
+	return resourceInstanceAutomatedBackupsReplicationRead(d, meta)
+}
+
+func resourceInstanceAutomatedBackupsReplicationRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*conns.AWSClient).RDSConn
+
+	backup, err := FindDBInstanceAutomatedBackupByARN(conn, d.Id())
+
+	if !d.IsNewResource() && tfresource.NotFound(err) {
+		log.Printf("[WARN] RDS instance automated backup %s not found, removing from state", d.Id())
+		d.SetId("")
+		return nil
+	}
+
+	if err != nil {
+		return fmt.Errorf("error reading RDS instance automated backup (%s): %w", d.Id(), err)
+	}
+
+	d.Set("kms_key_id", backup.KmsKeyId)
+	d.Set("retention_period", backup.BackupRetentionPeriod)
+	d.Set("source_db_instance_arn", backup.DBInstanceArn)
+
+	return nil
+}
+
+func resourceInstanceAutomatedBackupsReplicationDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*conns.AWSClient).RDSConn
+
+	backup, err := FindDBInstanceAutomatedBackupByARN(conn, d.Id())
+
+	if tfresource.NotFound(err) {
+		return nil
+	}
+
+	if err != nil {
+		return fmt.Errorf("error reading RDS instance automated backup (%s): %w", d.Id(), err)
+	}
+
+	dbInstanceID := aws.StringValue(backup.DBInstanceIdentifier)
+	sourceDatabaseARN, err := arn.Parse(aws.StringValue(backup.DBInstanceArn))
+
+	if err != nil {
+		return err
+	}
+
+	log.Printf("[DEBUG] Stopping RDS instance automated backups replication: %s", d.Id())
+	_, err = conn.StopDBInstanceAutomatedBackupsReplication(&rds.StopDBInstanceAutomatedBackupsReplicationInput{
+		SourceDBInstanceArn: aws.String(d.Get("source_db_instance_arn").(string)),
+	})
+
+	if err != nil {
+		return fmt.Errorf("error stopping RDS instance automated backups replication (%s): %w", d.Id(), err)
+	}
+
+	// Create a new client to the source region.
+	sourceDatabaseConn := conn
+	if sourceDatabaseARN.Region != meta.(*conns.AWSClient).Region {
+		sourceDatabaseConn = rds.New(meta.(*conns.AWSClient).Session, aws.NewConfig().WithRegion(sourceDatabaseARN.Region))
+	}
+
+	if _, err := waitDBInstanceAutomatedBackupDeleted(sourceDatabaseConn, dbInstanceID, d.Id(), d.Timeout(schema.TimeoutCreate)); err != nil {
+		return fmt.Errorf("error waiting for DB instance automated backup (%s) delete: %w", d.Id(), err)
+	}
+
+	return nil
+}