Add support for AWS Lambda Functions powered by AWS Graviton2 processors

.changelog/21091.txt

@@ -0,0 +1,19 @@
+```
+release-note:enhancement
+resource/aws_lambda_function: Add support for Graviton2 with `architectures` field
+```
+
+```
+release-note:enhancement
+resource/aws_lambda_layer_version: Add support for Graviton2 with `compatible_architectures` field
+```
+
+```
+release-note:enhancement
+data-source/aws_lambda_function: Add support for Graviton2 with `architectures` field
+```
+
+```
+release-note:enhancement
+data-source/aws_lambda_layer_version: Add support for Graviton2 with `compatible_architectures` field
+```

aws/data_source_aws_lambda_function.go

@@ -182,6 +182,13 @@ func dataSourceAwsLambdaFunction() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"architectures": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
 		},
 	}
 }
@@ -335,5 +342,9 @@ func dataSourceAwsLambdaFunctionRead(d *schema.ResourceData, meta interface{}) e
 
 	d.SetId(aws.StringValue(function.FunctionName))
 
+	if err := d.Set("architectures", flattenStringList(function.Architectures)); err != nil {
+		return fmt.Errorf("Error setting architectures for Lambda Function (%s): %w", d.Id(), err)
+	}
+
 	return nil
 }

aws/data_source_aws_lambda_function_test.go

@@ -211,6 +211,26 @@ func TestAccDataSourceAWSLambdaFunction_imageConfig(t *testing.T) {
 	})
 }
 
+func TestAccDataSourceAWSLambdaFunction_architectures(t *testing.T) {
+	rName := acctest.RandomWithPrefix("tf-acc-test")
+	dataSourceName := "data.aws_lambda_function.test"
+	resourceName := "aws_lambda_function.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:   func() { testAccPreCheck(t) },
+		ErrorCheck: testAccErrorCheck(t, lambda.EndpointsID),
+		Providers:  testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceAWSLambdaFunctionConfigArchitectures(rName),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrPair(dataSourceName, "architectures", resourceName, "architectures"),
+				),
+			},
+		},
+	})
+}
+
 func testAccDataSourceAWSLambdaFunctionConfigBase(rName string) string {
 	return fmt.Sprintf(`
 resource "aws_iam_role" "lambda" {
@@ -549,6 +569,23 @@ data "aws_lambda_function" "test" {
 `, imageID, rName))
 }
 
+func testAccDataSourceAWSLambdaFunctionConfigArchitectures(rName string) string {
+	return testAccDataSourceAWSLambdaFunctionConfigBase(rName) + fmt.Sprintf(`
+resource "aws_lambda_function" "test" {
+  filename      = "test-fixtures/lambdatest.zip"
+  function_name = %[1]q
+  handler       = "exports.example"
+  role          = aws_iam_role.lambda.arn
+  runtime       = "nodejs12.x"
+  architectures = ["arm64"]
+}
+
+data "aws_lambda_function" "test" {
+  function_name = aws_lambda_function.test.function_name
+}
+`, rName)
+}
+
 func testAccDataSourceLambdaImagePreCheck(t *testing.T) {
 	if os.Getenv("AWS_LAMBDA_IMAGE_LATEST_ID") == "" {
 		t.Skip("AWS_LAMBDA_IMAGE_LATEST_ID env var must be set for Lambda Function Data Source Image Support acceptance tests.")

aws/data_source_aws_lambda_layer_version.go

@@ -74,6 +74,19 @@ func dataSourceAwsLambdaLayerVersion() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"compatible_architecture": {
+				Type:          schema.TypeString,
+				Optional:      true,
+				ValidateFunc:  validation.StringInSlice(lambda.Architecture_Values(), false),
+				ConflictsWith: []string{"version"},
+			},
+			"compatible_architectures": {
+				Type:     schema.TypeSet,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
 		},
 	}
 }
@@ -94,6 +107,10 @@ func dataSourceAwsLambdaLayerVersionRead(d *schema.ResourceData, meta interface{
 			listInput.CompatibleRuntime = aws.String(v.(string))
 		}
 
+		if v, ok := d.GetOk("compatible_architecture"); ok {
+			listInput.CompatibleArchitecture = aws.String(v.(string))
+		}
+
 		log.Printf("[DEBUG] Looking up latest version for lambda layer %s", layerName)
 		listOutput, err := conn.ListLayerVersions(listInput)
 		if err != nil {
@@ -129,6 +146,9 @@ func dataSourceAwsLambdaLayerVersionRead(d *schema.ResourceData, meta interface{
 	if err := d.Set("compatible_runtimes", flattenStringList(output.CompatibleRuntimes)); err != nil {
 		return fmt.Errorf("error setting lambda layer compatible runtimes: %w", err)
 	}
+	if err := d.Set("compatible_architectures", flattenStringList(output.CompatibleArchitectures)); err != nil {
+		return fmt.Errorf("Error setting lambda layer compatible architectures: %w", err)
+	}
 	if err := d.Set("description", output.Description); err != nil {
 		return fmt.Errorf("error setting lambda layer description: %w", err)
 	}

aws/data_source_aws_lambda_layer_version_test.go

@@ -82,6 +82,48 @@ func TestAccDataSourceAWSLambdaLayerVersion_runtime(t *testing.T) {
 	})
 }
 
+func TestAccDataSourceAWSLambdaLayerVersion_architectures(t *testing.T) {
+	rName := acctest.RandomWithPrefix("tf-acc-test")
+	dataSourceName := "data.aws_lambda_layer_version.test"
+	resourceName := "aws_lambda_layer_version.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:   func() { testAccPreCheck(t) },
+		ErrorCheck: testAccErrorCheck(t, lambda.EndpointsID),
+		Providers:  testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesX86(rName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttrPair(dataSourceName, "layer_name", resourceName, "layer_name"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "compatible_architectures", resourceName, "compatible_architectures"),
+				),
+			},
+			{
+				Config: testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesARM(rName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttrPair(dataSourceName, "layer_name", resourceName, "layer_name"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "compatible_architectures", resourceName, "compatible_architectures"),
+				),
+			},
+			{
+				Config: testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesX86ARM(rName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttrPair(dataSourceName, "layer_name", resourceName, "layer_name"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "compatible_architectures", resourceName, "compatible_architectures"),
+				),
+			},
+			{
+				Config: testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesNone(rName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttrPair(dataSourceName, "layer_name", resourceName, "layer_name"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "compatible_architectures", resourceName, "compatible_architectures"),
+				),
+			},
+		},
+	})
+}
+
 func testAccDataSourceAWSLambdaLayerVersionConfigBasic(rName string) string {
 	return fmt.Sprintf(`
 resource "aws_lambda_layer_version" "test" {
@@ -137,3 +179,66 @@ data "aws_lambda_layer_version" "test" {
 }
 `, rName)
 }
+
+func testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesX86(rName string) string {
+	return fmt.Sprintf(`
+resource "aws_lambda_layer_version" "test" {
+  filename                 = "test-fixtures/lambdatest.zip"
+  layer_name               = %[1]q
+  compatible_runtimes      = ["nodejs12.x"]
+  compatible_architectures = ["x86_64"]
+}
+
+data "aws_lambda_layer_version" "test" {
+  layer_name              = aws_lambda_layer_version.test.layer_name
+  compatible_architecture = "x86_64"
+}
+
+`, rName)
+}
+
+func testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesARM(rName string) string {
+	return fmt.Sprintf(`
+resource "aws_lambda_layer_version" "test" {
+  filename                 = "test-fixtures/lambdatest.zip"
+  layer_name               = %[1]q
+  compatible_runtimes      = ["nodejs12.x"]
+  compatible_architectures = ["arm64"]
+}
+
+data "aws_lambda_layer_version" "test" {
+  layer_name              = aws_lambda_layer_version.test.layer_name
+  compatible_architecture = "arm64"
+}
+`, rName)
+}
+
+func testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesX86ARM(rName string) string {
+	return fmt.Sprintf(`
+resource "aws_lambda_layer_version" "test" {
+  filename                 = "test-fixtures/lambdatest.zip"
+  layer_name               = %[1]q
+  compatible_runtimes      = ["nodejs12.x"]
+  compatible_architectures = ["x86_64", "arm64"]
+}
+
+data "aws_lambda_layer_version" "test" {
+  layer_name              = aws_lambda_layer_version.test.layer_name
+  compatible_architecture = "arm64"
+}
+`, rName)
+}
+
+func testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesNone(rName string) string {
+	return fmt.Sprintf(`
+resource "aws_lambda_layer_version" "test" {
+  filename            = "test-fixtures/lambdatest.zip"
+  layer_name          = %[1]q
+  compatible_runtimes = ["nodejs12.x"]
+}
+
+data "aws_lambda_layer_version" "test" {
+  layer_name = aws_lambda_layer_version.test.layer_name
+}
+`, rName)
+}

aws/resource_aws_lambda_function.go

@@ -47,6 +47,16 @@ func resourceAwsLambdaFunction() *schema.Resource {
 		},
 
 		Schema: map[string]*schema.Schema{
+			"architectures": {
+				Type:     schema.TypeList,
+				Optional: true,
+				Computed: true,
+				MaxItems: 1,
+				Elem: &schema.Schema{
+					Type:         schema.TypeString,
+					ValidateFunc: validation.StringInSlice(lambda.Architecture_Values(), false),
+				},
+			},
 			"filename": {
 				Type:          schema.TypeString,
 				Optional:      true,
@@ -438,6 +448,10 @@ func resourceAwsLambdaFunctionCreate(d *schema.ResourceData, meta interface{}) e
 		PackageType:  aws.String(packageType),
 	}
 
+	if v, ok := d.GetOk("architectures"); ok && len(v.([]interface{})) > 0 {
+		params.Architectures = expandStringList(v.([]interface{}))
+	}
+
 	if packageType == lambda.PackageTypeZip {
 		params.Handler = aws.String(d.Get("handler").(string))
 		params.Runtime = aws.String(d.Get("runtime").(string))
@@ -675,6 +689,12 @@ func resourceAwsLambdaFunctionRead(d *schema.ResourceData, meta interface{}) err
 
 	function := getFunctionOutput.Configuration
 
+	architectures := flattenStringList(function.Architectures)
+	log.Printf("[INFO] Setting Lambda %s Architecture %#v from API", d.Id(), architectures)
+	if err := d.Set("architectures", architectures); err != nil {
+		return fmt.Errorf("error setting architectures for Lambda Function (%s): %w", d.Id(), err)
+	}
+
 	if err := d.Set("arn", function.FunctionArn); err != nil {
 		return fmt.Errorf("error setting function arn for Lambda Function: %w", err)
 	}
@@ -909,8 +929,8 @@ func needsFunctionCodeUpdate(d resourceDiffer) bool {
 		d.HasChange("s3_bucket") ||
 		d.HasChange("s3_key") ||
 		d.HasChange("s3_object_version") ||
-		d.HasChange("image_uri")
-
+		d.HasChange("image_uri") ||
+		d.HasChange("architectures")
 }
 
 // resourceAwsLambdaFunctionUpdate maps to:
@@ -1127,6 +1147,13 @@ func resourceAwsLambdaFunctionUpdate(d *schema.ResourceData, meta interface{}) e
 			FunctionName: aws.String(d.Id()),
 		}
 
+		if d.HasChange("architectures") {
+			architectures := d.Get("architectures").([]interface{})
+			if len(architectures) > 0 {
+				codeReq.Architectures = expandStringList(architectures)
+			}
+		}
+
 		if v, ok := d.GetOk("filename"); ok {
 			// Grab an exclusive lock so that we're only reading one function into
 			// memory at a time.