Merge pull request #1946 from hashicorp/f-aws-db-read-replicas

provider/aws: Add AWS RDS Read Replica

builtin/providers/aws/resource_aws_db_instance.go

@@ -26,6 +26,7 @@ func resourceAwsDbInstance() *schema.Resource {
  "name": &schema.Schema{
  Type: schema.TypeString,
  Optional: true,
+ Computed: true,
  ForceNew: true,
  },
 
@@ -89,7 +90,7 @@ func resourceAwsDbInstance() *schema.Resource {
  "backup_retention_period": &schema.Schema{
  Type: schema.TypeInt,
  Optional: true,
- Default: 1,
+ Computed: true,
  },
 
  "backup_window": &schema.Schema{
@@ -191,6 +192,17 @@ func resourceAwsDbInstance() *schema.Resource {
  Computed: true,
  },
 
+ "replicate_source_db": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ },
+
+ "replicas": &schema.Schema{
+ Type: schema.TypeList,
+ Computed: true,
+ Elem: &schema.Schema{Type: schema.TypeString},
+ },
+
  "tags": tagsSchema(),
  },
  }
@@ -199,87 +211,113 @@ func resourceAwsDbInstance() *schema.Resource {
 func resourceAwsDbInstanceCreate(d *schema.ResourceData, meta interface{}) error {
  conn := meta.(*AWSClient).rdsconn
  tags := tagsFromMapRDS(d.Get("tags").(map[string]interface{}))
- opts := rds.CreateDBInstanceInput{
- AllocatedStorage: aws.Long(int64(d.Get("allocated_storage").(int))),
- DBInstanceClass: aws.String(d.Get("instance_class").(string)),
- DBInstanceIdentifier: aws.String(d.Get("identifier").(string)),
- DBName: aws.String(d.Get("name").(string)),
- MasterUsername: aws.String(d.Get("username").(string)),
- MasterUserPassword: aws.String(d.Get("password").(string)),
- Engine: aws.String(d.Get("engine").(string)),
- EngineVersion: aws.String(d.Get("engine_version").(string)),
- StorageEncrypted: aws.Boolean(d.Get("storage_encrypted").(bool)),
- Tags: tags,
- }
 
- if attr, ok := d.GetOk("storage_type"); ok {
- opts.StorageType = aws.String(attr.(string))
- }
+ if v, ok := d.GetOk("replicate_source_db"); ok {
+ opts := rds.CreateDBInstanceReadReplicaInput{
+ SourceDBInstanceIdentifier: aws.String(v.(string)),
+ DBInstanceClass: aws.String(d.Get("instance_class").(string)),
+ DBInstanceIdentifier: aws.String(d.Get("identifier").(string)),
+ Tags: tags,
+ }
+ if attr, ok := d.GetOk("iops"); ok {
+ opts.IOPS = aws.Long(int64(attr.(int)))
+ }
 
- attr := d.Get("backup_retention_period")
- opts.BackupRetentionPeriod = aws.Long(int64(attr.(int)))
+ if attr, ok := d.GetOk("port"); ok {
+ opts.Port = aws.Long(int64(attr.(int)))
+ }
 
- if attr, ok := d.GetOk("iops"); ok {
- opts.IOPS = aws.Long(int64(attr.(int)))
- }
+  if attr, ok := d.GetOk("availability_zone"); ok {
+  opts.AvailabilityZone = aws.String(attr.(string))
+  }
 
- if attr, ok := d.GetOk("port"); ok {
- opts.Port = aws.Long(int64(attr.(int)))
- }
+ if attr, ok := d.GetOk("publicly_accessible"); ok {
+ opts.PubliclyAccessible = aws.Boolean(attr.(bool))
+ }
+ _, err := conn.CreateDBInstanceReadReplica(&opts)
+ if err != nil {
+ return fmt.Errorf("Error creating DB Instance: %s", err)
+ }
+ } else {
+ opts := rds.CreateDBInstanceInput{
+ AllocatedStorage: aws.Long(int64(d.Get("allocated_storage").(int))),
+ DBName: aws.String(d.Get("name").(string)),
+ DBInstanceClass: aws.String(d.Get("instance_class").(string)),
+ DBInstanceIdentifier: aws.String(d.Get("identifier").(string)),
+ MasterUsername: aws.String(d.Get("username").(string)),
+ MasterUserPassword: aws.String(d.Get("password").(string)),
+ Engine: aws.String(d.Get("engine").(string)),
+ EngineVersion: aws.String(d.Get("engine_version").(string)),
+ StorageEncrypted: aws.Boolean(d.Get("storage_encrypted").(bool)),
+ Tags: tags,
+ }
 
- if attr, ok := d.GetOk("multi_az"); ok {
- opts.MultiAZ = aws.Boolean(attr.(bool))
- }
+ attr := d.Get("backup_retention_period")
+ opts.BackupRetentionPeriod = aws.Long(int64(attr.(int)))
+ if attr, ok := d.GetOk("multi_az"); ok {
+ opts.MultiAZ = aws.Boolean(attr.(bool))
+ }
 
- if attr, ok := d.GetOk("availability_zone"); ok {
- opts.AvailabilityZone = aws.String(attr.(string))
- }
+  if attr, ok := d.GetOk("maintenance_window"); ok {
+  opts.PreferredMaintenanceWindow = aws.String(attr.(string))
+  }
 
- if attr, ok := d.GetOk("license_model"); ok {
- opts.LicenseModel = aws.String(attr.(string))
- }
+  if attr, ok := d.GetOk("backup_window"); ok {
+  opts.PreferredBackupWindow = aws.String(attr.(string))
+  }
 
- if attr, ok := d.GetOk("maintenance_window"); ok {
- opts.PreferredMaintenanceWindow = aws.String(attr.(string))
- }
+ if attr, ok := d.GetOk("license_model"); ok {
+ opts.LicenseModel = aws.String(attr.(string))
+ }
+ if attr, ok := d.GetOk("parameter_group_name"); ok {
+ opts.DBParameterGroupName = aws.String(attr.(string))
+ }
 
- if attr, ok := d.GetOk("backup_window"); ok {
- opts.PreferredBackupWindow = aws.String(attr.(string))
- }
+ if attr := d.Get("vpc_security_group_ids").(*schema.Set); attr.Len() > 0 {
+ var s []*string
+ for _, v := range attr.List() {
+ s = append(s, aws.String(v.(string)))
+ }
+ opts.VPCSecurityGroupIDs = s
+ }
 
- if attr, ok := d.GetOk("publicly_accessible"); ok {
- opts.PubliclyAccessible = aws.Boolean(attr.(bool))
- }
+ if attr := d.Get("security_group_names").(*schema.Set); attr.Len() > 0 {
+ var s []*string
+ for _, v := range attr.List() {
+ s = append(s, aws.String(v.(string)))
+ }
+ opts.DBSecurityGroups = s
+ }
+ if attr, ok := d.GetOk("storage_type"); ok {
+ opts.StorageType = aws.String(attr.(string))
+ }
 
- if attr, ok := d.GetOk("db_subnet_group_name"); ok {
- opts.DBSubnetGroupName = aws.String(attr.(string))
- }
+  if attr, ok := d.GetOk("db_subnet_group_name"); ok {
+  opts.DBSubnetGroupName = aws.String(attr.(string))
+  }
 
- if attr, ok := d.GetOk("parameter_group_name"); ok {
- opts.DBParameterGroupName = aws.String(attr.(string))
- }
+  if attr, ok := d.GetOk("iops"); ok {
+  opts.IOPS = aws.Long(int64(attr.(int)))
+  }
 
- if attr := d.Get("vpc_security_group_ids").(*schema.Set); attr.Len() > 0 {
- var s []*string
- for _, v := range attr.List() {
- s = append(s, aws.String(v.(string)))
+ if attr, ok := d.GetOk("port"); ok {
+ opts.Port = aws.Long(int64(attr.(int)))
  }
- opts.VPCSecurityGroupIDs = s
- }
 
- if attr := d.Get("security_group_names").(*schema.Set); attr.Len() > 0 {
- var s []*string
- for _, v := range attr.List() {
- s = append(s, aws.String(v.(string)))
+ if attr, ok := d.GetOk("availability_zone"); ok {
+ opts.AvailabilityZone = aws.String(attr.(string))
  }
- opts.DBSecurityGroups = s
- }
 
- log.Printf("[DEBUG] DB Instance create configuration: %#v", opts)
- var err error
- _, err = conn.CreateDBInstance(&opts)
- if err != nil {
- return fmt.Errorf("Error creating DB Instance: %s", err)
+ if attr, ok := d.GetOk("publicly_accessible"); ok {
+ opts.PubliclyAccessible = aws.Boolean(attr.(bool))
+ }
+
+ log.Printf("[DEBUG] DB Instance create configuration: %#v", opts)
+ var err error
+ _, err = conn.CreateDBInstance(&opts)
+ if err != nil {
+ return fmt.Errorf("Error creating DB Instance: %s", err)
+ }
  }
 
  d.SetId(d.Get("identifier").(string))
@@ -299,7 +337,7 @@ func resourceAwsDbInstanceCreate(d *schema.ResourceData, meta interface{}) error
  }
 
  // Wait, catching any errors
- _, err = stateConf.WaitForState()
+ _, err := stateConf.WaitForState()
  if err != nil {
  return err
  }
@@ -397,6 +435,18 @@ func resourceAwsDbInstanceRead(d *schema.ResourceData, meta interface{}) error {
  }
  d.Set("security_group_names", sgn)
 
+ // replica things
+
+ var replicas []string
+ for _, v := range v.ReadReplicaDBInstanceIdentifiers {
+ replicas = append(replicas, *v)
+ }
+ if err := d.Set("replicas", replicas); err != nil {
+ return fmt.Errorf("[DEBUG] Error setting replicas attribute: %#v, error: %#v", replicas, err)
+ }
+
+ d.Set("replicate_source_db", v.ReadReplicaSourceDBInstanceIdentifier)
+
  return nil
 }
 
@@ -536,6 +586,28 @@ func resourceAwsDbInstanceUpdate(d *schema.ResourceData, meta interface{}) error
  }
  }
 
+ // seperate request to promote a database
+ if d.HasChange("replicate_source_db") {
+ if d.Get("replicate_source_db").(string) == "" {
+ // promote
+ opts := rds.PromoteReadReplicaInput{
+ DBInstanceIdentifier: aws.String(d.Id()),
+ }
+ attr := d.Get("backup_retention_period")
+ opts.BackupRetentionPeriod = aws.Long(int64(attr.(int)))
+ if attr, ok := d.GetOk("backup_window"); ok {
+ opts.PreferredBackupWindow = aws.String(attr.(string))
+ }
+ _, err := conn.PromoteReadReplica(&opts)
+ if err != nil {
+ return fmt.Errorf("Error promoting database: %#v", err)
+ }
+ d.Set("replicate_source_db", "")
+ } else {
+ return fmt.Errorf("cannot elect new source database for replication")
+ }
+ }
+
  if arn, err := buildRDSARN(d, meta); err == nil {
  if err := setTagsRDS(conn, d, arn); err != nil {
  return err
@@ -591,6 +663,10 @@ func resourceAwsDbInstanceStateRefreshFunc(
  return nil, "", nil
  }
 
+ if v.DBInstanceStatus != nil {
+ log.Printf("[DEBUG] DB Instance status for instance %s: %s", d.Id(), *v.DBInstanceStatus)
+ }
+
  return v, *v.DBInstanceStatus, nil
  }
 }

builtin/providers/aws/resource_aws_db_instance_test.go

@@ -49,6 +49,26 @@ func TestAccAWSDBInstance(t *testing.T) {
  })
 }
 
+func TestAccAWSDBInstanceReplica(t *testing.T) {
+ var s, r rds.DBInstance
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testAccCheckAWSDBInstanceDestroy,
+ Steps: []resource.TestStep{
+ resource.TestStep{
+ Config: testAccReplicaInstanceConfig(rand.New(rand.NewSource(time.Now().UnixNano())).Int()),
+ Check: resource.ComposeTestCheckFunc(
+ testAccCheckAWSDBInstanceExists("aws_db_instance.bar", &s),
+ testAccCheckAWSDBInstanceExists("aws_db_instance.replica", &r),
+ testAccCheckAWSDBInstanceReplicaAttributes(&s, &r),
+ ),
+ },
+ },
+ })
+}
+
 func testAccCheckAWSDBInstanceDestroy(s *terraform.State) error {
  conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
@@ -103,6 +123,17 @@ func testAccCheckAWSDBInstanceAttributes(v *rds.DBInstance) resource.TestCheckFu
  }
 }
 
+func testAccCheckAWSDBInstanceReplicaAttributes(source, replica *rds.DBInstance) resource.TestCheckFunc {
+ return func(s *terraform.State) error {
+
+ if replica.ReadReplicaSourceDBInstanceIdentifier != nil && *replica.ReadReplicaSourceDBInstanceIdentifier != *source.DBInstanceIdentifier {
+ return fmt.Errorf("bad source identifier for replica, expected: '%s', got: '%s'", *source.DBInstanceIdentifier, *replica.ReadReplicaSourceDBInstanceIdentifier)
+ }
+
+ return nil
+ }
+}
+
 func testAccCheckAWSDBInstanceExists(n string, v *rds.DBInstance) resource.TestCheckFunc {
  return func(s *terraform.State) error {
  rs, ok := s.RootModule().Resources[n]
@@ -156,3 +187,38 @@ resource "aws_db_instance" "bar" {
 
  parameter_group_name = "default.mysql5.6"
 }`, rand.New(rand.NewSource(time.Now().UnixNano())).Int())
+
+func testAccReplicaInstanceConfig(val int) string {
+ return fmt.Sprintf(`
+ resource "aws_db_instance" "bar" {
+ identifier = "foobarbaz-test-terraform-%d"
+
+ allocated_storage = 5
+ engine = "mysql"
+ engine_version = "5.6.21"
+ instance_class = "db.t1.micro"
+ name = "baz"
+ password = "barbarbarbar"
+ username = "foo"
+
+ backup_retention_period = 1
+
+ parameter_group_name = "default.mysql5.6"
+ }
+ 
+ resource "aws_db_instance" "replica" {
+ identifier = "tf-replica-db-%d"
+ backup_retention_period = 0
+ replicate_source_db = "${aws_db_instance.bar.identifier}"
+ allocated_storage = "${aws_db_instance.bar.allocated_storage}"
+ engine = "${aws_db_instance.bar.engine}"
+ engine_version = "${aws_db_instance.bar.engine_version}"
+ instance_class = "${aws_db_instance.bar.instance_class}"
+ password = "${aws_db_instance.bar.password}"
+ username = "${aws_db_instance.bar.username}"
+ tags {
+ Name = "tf-replica-db"
+ }
+ }
+ `, val, val)
+}

website/source/docs/providers/aws/r/db_instance.html.markdown

@@ -48,7 +48,8 @@ The following arguments are supported:
  show up in logs, and it will be stored in the state file.
 * `username` - (Required) Username for the master DB user.
 * `availability_zone` - (Optional) The AZ for the RDS instance.
-* `backup_retention_period` - (Optional) The days to retain backups for.
+* `backup_retention_period` - (Optional) The days to retain backups for. Must be
+`1` or greater to be a source for a [Read Replica][1].
 * `backup_window` - (Optional) The backup window.
 * `iops` - (Optional) The amount of provisioned IOPS. Setting this implies a
  storage_type of "io1".
@@ -65,6 +66,17 @@ The following arguments are supported:
 * `apply_immediately` - (Optional) Specifies whether any database modifications
  are applied immediately, or during the next maintenance window. Default is
  `false`. See [Amazon RDS Documentation for more for more information.](http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Modifying.html)
+* `replicate_source_db` - (Optional) Specifies that this resource is a Replicate
+database, and to use this value as the source database. This correlates to the
+`identifier` of another Amazon RDS Database to replicate. See
+[DB Instance Replication][1] and
+[Working with PostgreSQL and MySQL Read Replicas](http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html) for
+ more information on using Replication.
+
+
+~> **NOTE:** Removing the `replicate_source_db` attribute from an existing RDS
+Replicate database managed by Terraform will promote the database to a fully
+standalone database.
 
 ## Attributes Reference
 
@@ -88,3 +100,5 @@ The following attributes are exported:
 * `username` - The master username for the database
 * `storage_encrypted` - Specifies whether the DB instance is encrypted
 
+
+[1]: http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Replication.html