EBS default encryption

aws/provider.go

@@ -426,6 +426,8 @@ func Provider() terraform.ResourceProvider {
 			"aws_dynamodb_table":                                      resourceAwsDynamoDbTable(),
 			"aws_dynamodb_table_item":                                 resourceAwsDynamoDbTableItem(),
 			"aws_dynamodb_global_table":                               resourceAwsDynamoDbGlobalTable(),
+			"aws_ebs_default_kms_key":                                 resourceAwsEbsDefaultKmsKey(),
+			"aws_ebs_encryption_by_default":                           resourceAwsEbsEncryptionByDefault(),
 			"aws_ebs_snapshot":                                        resourceAwsEbsSnapshot(),
 			"aws_ebs_snapshot_copy":                                   resourceAwsEbsSnapshotCopy(),
 			"aws_ebs_volume":                                          resourceAwsEbsVolume(),

aws/resource_aws_ebs_default_kms_key.go

@@ -0,0 +1,80 @@
+package aws
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceAwsEbsDefaultKmsKey() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsEbsDefaultKmsKeyCreate,
+		Read:   resourceAwsEbsDefaultKmsKeyRead,
+		Update: resourceAwsEbsDefaultKmsKeyUpdate,
+		Delete: resourceAwsEbsDefaultKmsKeyDelete,
+
+		Schema: map[string]*schema.Schema{
+			"key_id": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ValidateFunc: validateArn,
+			},
+		},
+	}
+}
+
+func resourceAwsEbsDefaultKmsKeyCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	_, err := conn.ModifyEbsDefaultKmsKeyId(&ec2.ModifyEbsDefaultKmsKeyIdInput{
+		KmsKeyId: aws.String(d.Get("key_id").(string)),
+	})
+	if err != nil {
+		return fmt.Errorf("error creating EBS default KMS key: %s", err)
+	}
+
+	d.SetId(resource.UniqueId())
+
+	return resourceAwsEbsDefaultKmsKeyRead(d, meta)
+}
+
+func resourceAwsEbsDefaultKmsKeyRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	resp, err := conn.GetEbsDefaultKmsKeyId(&ec2.GetEbsDefaultKmsKeyIdInput{})
+	if err != nil {
+		return fmt.Errorf("error reading EBS default KMS key: %s", err)
+	}
+
+	d.Set("key_id", aws.StringValue(resp.KmsKeyId))
+
+	return nil
+}
+
+func resourceAwsEbsDefaultKmsKeyUpdate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	_, err := conn.ModifyEbsDefaultKmsKeyId(&ec2.ModifyEbsDefaultKmsKeyIdInput{
+		KmsKeyId: aws.String(d.Get("key_id").(string)),
+	})
+	if err != nil {
+		return fmt.Errorf("error updating EBS default KMS key: %s", err)
+	}
+
+	return resourceAwsEbsDefaultKmsKeyRead(d, meta)
+}
+
+func resourceAwsEbsDefaultKmsKeyDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	_, err := conn.ResetEbsDefaultKmsKeyId(&ec2.ResetEbsDefaultKmsKeyIdInput{})
+	if err != nil {
+		return fmt.Errorf("error deleting EBS default KMS key: %s", err)
+	}
+
+	return nil
+}

aws/resource_aws_ebs_default_kms_key_test.go

@@ -0,0 +1,103 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/arn"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAWSEBSDefaultKmsKey_basic(t *testing.T) {
+	resourceName := "aws_ebs_default_kms_key.test"
+	resourceNameKey1 := "aws_kms_key.test1"
+	resourceNameKey2 := "aws_kms_key.test2"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsEbsDefaultKmsKeyDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAwsEbsDefaultKmsKeyConfig_basic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEbsDefaultKmsKey(resourceName),
+					resource.TestCheckResourceAttrPair(resourceName, "key_id", resourceNameKey1, "arn"),
+				),
+			},
+			{
+				Config: testAccAwsEbsDefaultKmsKeyConfig_updated,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEbsDefaultKmsKey(resourceName),
+					resource.TestCheckResourceAttrPair(resourceName, "key_id", resourceNameKey2, "arn"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckAwsEbsDefaultKmsKeyDestroy(s *terraform.State) error {
+	ec2conn := testAccProvider.Meta().(*AWSClient).ec2conn
+	kmsconn := testAccProvider.Meta().(*AWSClient).kmsconn
+
+	alias, err := findKmsAliasByName(kmsconn, "alias/aws/ebs", nil)
+	if err != nil {
+		return err
+	}
+
+	aliasARN, err := arn.Parse(aws.StringValue(alias.AliasArn))
+	if err != nil {
+		return err
+	}
+
+	arn := arn.ARN{
+		Partition: aliasARN.Partition,
+		Service:   aliasARN.Service,
+		Region:    aliasARN.Region,
+		AccountID: aliasARN.AccountID,
+		Resource:  fmt.Sprintf("key/%s", aws.StringValue(alias.TargetKeyId)),
+	}
+
+	resp, err := ec2conn.GetEbsDefaultKmsKeyId(&ec2.GetEbsDefaultKmsKeyIdInput{})
+	if err != nil {
+		return err
+	}
+
+	if aws.StringValue(resp.KmsKeyId) != arn.String() {
+		return fmt.Errorf("Default CMK (%s) is not the account's AWS-managed default CMK (%s)", aws.StringValue(resp.KmsKeyId), arn.String())
+	}
+
+	return nil
+}
+
+func testAccCheckEbsDefaultKmsKey(name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		_, ok := s.RootModule().Resources[name]
+		if !ok {
+			return fmt.Errorf("Not found: %s", name)
+		}
+
+		return nil
+	}
+}
+
+const testAccAwsEbsDefaultKmsKeyConfigBase = `
+resource "aws_kms_key" "test1" {}
+
+resource "aws_kms_key" "test2" {}
+`
+
+const testAccAwsEbsDefaultKmsKeyConfig_basic = testAccAwsEbsDefaultKmsKeyConfigBase + `
+resource "aws_ebs_default_kms_key" "test" {
+  key_id = "${aws_kms_key.test1.arn}"
+}
+`
+
+const testAccAwsEbsDefaultKmsKeyConfig_updated = testAccAwsEbsDefaultKmsKeyConfigBase + `
+resource "aws_ebs_default_kms_key" "test" {
+  key_id = "${aws_kms_key.test2.arn}"
+}
+`

aws/resource_aws_ebs_encryption_by_default.go

@@ -0,0 +1,80 @@
+package aws
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceAwsEbsEncryptionByDefault() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsEbsEncryptionByDefaultCreate,
+		Read:   resourceAwsEbsEncryptionByDefaultRead,
+		Update: resourceAwsEbsEncryptionByDefaultUpdate,
+		Delete: resourceAwsEbsEncryptionByDefaultDelete,
+
+		Schema: map[string]*schema.Schema{
+			"enabled": {
+				Type:     schema.TypeBool,
+				Required: true,
+			},
+		},
+	}
+}
+
+func resourceAwsEbsEncryptionByDefaultCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	enabled := d.Get("enabled").(bool)
+	if err := setEbsEncryptionByDefault(conn, enabled); err != nil {
+		return fmt.Errorf("error creating EBS encryption by default (%t): %s", enabled, err)
+	}
+
+	d.SetId(resource.UniqueId())
+
+	return resourceAwsEbsEncryptionByDefaultRead(d, meta)
+}
+
+func resourceAwsEbsEncryptionByDefaultRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	resp, err := conn.GetEbsEncryptionByDefault(&ec2.GetEbsEncryptionByDefaultInput{})
+	if err != nil {
+		return fmt.Errorf("error reading EBS encryption by default: %s", err)
+	}
+
+	d.Set("enabled", aws.BoolValue(resp.EbsEncryptionByDefault))
+
+	return nil
+}
+
+func resourceAwsEbsEncryptionByDefaultUpdate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	enabled := d.Get("enabled").(bool)
+	if err := setEbsEncryptionByDefault(conn, enabled); err != nil {
+		return fmt.Errorf("error updating EBS encryption by default (%t): %s", enabled, err)
+	}
+
+	return resourceAwsEbsEncryptionByDefaultRead(d, meta)
+}
+
+func resourceAwsEbsEncryptionByDefaultDelete(d *schema.ResourceData, meta interface{}) error {
+	return nil
+}
+
+func setEbsEncryptionByDefault(conn *ec2.EC2, enabled bool) error {
+	var err error
+
+	if enabled {
+		_, err = conn.EnableEbsEncryptionByDefault(&ec2.EnableEbsEncryptionByDefaultInput{})
+	} else {
+		_, err = conn.DisableEbsEncryptionByDefault(&ec2.DisableEbsEncryptionByDefaultInput{})
+	}
+
+	return err
+}

aws/resource_aws_ebs_encryption_by_default_test.go

@@ -0,0 +1,70 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAWSEBSEncryptionByDefault_basic(t *testing.T) {
+	resourceName := "aws_ebs_encryption_by_default.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAwsEbsEncryptionByDefaultConfig(false),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEbsEncryptionByDefault(resourceName, false),
+					resource.TestCheckResourceAttr(resourceName, "enabled", "false"),
+				),
+			},
+			{
+				Config: testAccAwsEbsEncryptionByDefaultConfig(true),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEbsEncryptionByDefault(resourceName, true),
+					resource.TestCheckResourceAttr(resourceName, "enabled", "true"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckEbsEncryptionByDefault(n string, enabled bool) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
+
+		response, err := conn.GetEbsEncryptionByDefault(&ec2.GetEbsEncryptionByDefaultInput{})
+		if err != nil {
+			return err
+		}
+
+		if aws.BoolValue(response.EbsEncryptionByDefault) != enabled {
+			return fmt.Errorf("EBS encryption by default is not in expected state (%t)", enabled)
+		}
+
+		return nil
+	}
+}
+
+func testAccAwsEbsEncryptionByDefaultConfig(enabled bool) string {
+	return fmt.Sprintf(`
+resource "aws_ebs_encryption_by_default" "test" {
+  enabled = %[1]t
+}
+`, enabled)
+}

website/aws.erb

@@ -1135,6 +1135,14 @@
                             <a href="/docs/providers/aws/r/ami_launch_permission.html">aws_ami_launch_permission</a>
                         </li>
 
+                        <li>
+                          <a href="/docs/providers/aws/r/ebs_default_kms_key.html">aws_ebs_default_kms_key</a>
+                        </li>
+
+                        <li>
+                          <a href="/docs/providers/aws/r/ebs_encryption_by_default.html">aws_ebs_encryption_by_default</a>
+                        </li>
+
                         <li>
                           <a href="/docs/providers/aws/r/ebs_snapshot.html">aws_ebs_snapshot</a>
                         </li>

website/docs/r/ebs_default_kms_key.html.markdown

@@ -0,0 +1,32 @@
+---
+layout: "aws"
+page_title: "AWS: aws_ebs_default_kms_key"
+sidebar_current: "docs-aws-ebs-default-kms-key"
+description: |-
+  Manages the default customer master key (CMK) that your AWS account uses to encrypt EBS volumes.
+---
+
+# Resource: aws_ebs_default_kms_key
+
+Provides a resource to manage the default customer master key (CMK) that your AWS account uses to encrypt EBS volumes.
+
+Your AWS account has an AWS-managed default CMK that is used for encrypting an EBS volume when no CMK is specified in the API call that creates the volume.
+By using the `aws_ebs_default_kms_key` resource, you can specify a customer-managed CMK to use in place of the AWS-managed default CMK.
+
+~> **NOTE:** Creating an `aws_ebs_default_kms_key` resource does not enable default EBS encryption. Use the [`aws_ebs_encryption_by_default`](ebs_encryption_by_default.html) to enable default EBS encryption.
+
+~> **NOTE:** Destroying this resource will reset the default CMK to the account's AWS-managed default CMK for EBS.
+
+## Example Usage
+
+```hcl
+resource "aws_ebs_default_kms_key" "example" {
+  key_id = "${aws_kms_key.example.arn}"
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `key_id` - (Required) The ARN of the AWS Key Management Service (AWS KMS) customer master key (CMK) to use to encrypt the EBS volume.