From 6e6db8ca2e8177ac07e4592ccb849170ace9e4ec Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Mon, 6 Sep 2021 22:22:02 +0800 Subject: [PATCH 01/18] add arm lambda functions support --- aws/data_source_aws_lambda_function.go | 11 +++ aws/data_source_aws_lambda_function_test.go | 37 ++++++++++ aws/resource_aws_lambda_function.go | 25 ++++++- aws/resource_aws_lambda_function_test.go | 78 +++++++++++++++++++++ 4 files changed, 149 insertions(+), 2 deletions(-) diff --git a/aws/data_source_aws_lambda_function.go b/aws/data_source_aws_lambda_function.go index bda952f988dc..bc60f825ea94 100644 --- a/aws/data_source_aws_lambda_function.go +++ b/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 } diff --git a/aws/data_source_aws_lambda_function_test.go b/aws/data_source_aws_lambda_function_test.go index 4d065ebae282..aa8bc45e9e23 100644 --- a/aws/data_source_aws_lambda_function_test.go +++ b/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.") diff --git a/aws/resource_aws_lambda_function.go b/aws/resource_aws_lambda_function.go index 829ae0c00f63..d0fb57a32da3 100644 --- a/aws/resource_aws_lambda_function.go +++ b/aws/resource_aws_lambda_function.go @@ -47,6 +47,12 @@ func resourceAwsLambdaFunction() *schema.Resource { }, Schema: map[string]*schema.Schema{ + "architectures": { + Type: schema.TypeList, + Optional: true, + MaxItems: 1, + Elem: &schema.Schema{Type: schema.TypeString}, + }, "filename": { Type: schema.TypeString, Optional: true, @@ -438,6 +444,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 +685,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 +925,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 +1143,11 @@ func resourceAwsLambdaFunctionUpdate(d *schema.ResourceData, meta interface{}) e FunctionName: aws.String(d.Id()), } + if d.HasChange("architectures") { + architectures := d.Get("architectures").([]interface{}) + 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. diff --git a/aws/resource_aws_lambda_function_test.go b/aws/resource_aws_lambda_function_test.go index 57148736e2e6..28d4a59e8401 100644 --- a/aws/resource_aws_lambda_function_test.go +++ b/aws/resource_aws_lambda_function_test.go @@ -999,6 +999,58 @@ func TestAccAWSLambdaFunction_imageConfig(t *testing.T) { }) } +func TestAccAWSLambdaFunction_Architectures(t *testing.T) { + var conf lambda.GetFunctionOutput + resourceName := "aws_lambda_function.test" + + rString := acctest.RandString(8) + funcName := fmt.Sprintf("tf_acc_lambda_func_basic_%s", rString) + policyName := fmt.Sprintf("tf_acc_policy_lambda_func_basic_%s", rString) + roleName := fmt.Sprintf("tf_acc_role_lambda_func_basic_%s", rString) + sgName := fmt.Sprintf("tf_acc_sg_lambda_func_basic_%s", rString) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + ErrorCheck: testAccErrorCheck(t, lambda.EndpointsID), + Providers: testAccProviders, + CheckDestroy: testAccCheckLambdaFunctionDestroy, + Steps: []resource.TestStep{ + // Ensure function with arm64 architecture can be created + { + Config: testAccAWSLambdaArchitecturesARM64(funcName, policyName, roleName, sgName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), + testAccCheckAwsLambdaFunctionName(&conf, funcName), + testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), + testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), + resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.0", "arm64"), + ), + }, + // Ensure configuration can be imported + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"filename", "publish"}, + }, + // Ensure function architecture can be updated + { + Config: testAccAWSLambdaArchitecturesUpdate(funcName, policyName, roleName, sgName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), + testAccCheckAwsLambdaFunctionName(&conf, funcName), + testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), + testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), + resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.0", "x86_64"), + ), + }, + }, + }) + +} + func TestAccAWSLambdaFunction_tracingConfig(t *testing.T) { if got, want := testAccGetPartition(), endpoints.AwsUsGovPartitionID; got == want { t.Skipf("Lambda tracing config is not supported in %s partition", got) @@ -2708,6 +2760,32 @@ resource "aws_lambda_function" "test" { `, imageID, funcName) } +func testAccAWSLambdaArchitecturesARM64(funcName, policyName, roleName, sgName string) string { + return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` +resource "aws_lambda_function" "test" { + filename = "test-fixtures/lambdatest.zip" + function_name = "%s" + role = aws_iam_role.iam_for_lambda.arn + handler = "exports.example" + runtime = "nodejs12.x" + architectures = ["arm64"] +} +`, funcName) +} + +func testAccAWSLambdaArchitecturesUpdate(funcName, policyName, roleName, sgName string) string { + return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` +resource "aws_lambda_function" "test" { + filename = "test-fixtures/lambdatest.zip" + function_name = "%s" + role = aws_iam_role.iam_for_lambda.arn + handler = "exports.example" + runtime = "nodejs12.x" + architectures = ["x86_64"] +} +`, funcName) +} + func testAccAWSLambdaConfigVersionedNodeJs10xRuntime(fileName, funcName, policyName, roleName, sgName string) string { return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` resource "aws_lambda_function" "test" { From 99f8eb6353da3853c2901bbc62fe75cd77c7e839 Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Mon, 6 Sep 2021 22:40:31 +0800 Subject: [PATCH 02/18] add validation for 'architectures' --- aws/resource_aws_lambda_function.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/aws/resource_aws_lambda_function.go b/aws/resource_aws_lambda_function.go index d0fb57a32da3..86a8ee24cc3d 100644 --- a/aws/resource_aws_lambda_function.go +++ b/aws/resource_aws_lambda_function.go @@ -51,7 +51,10 @@ func resourceAwsLambdaFunction() *schema.Resource { Type: schema.TypeList, Optional: true, MaxItems: 1, - Elem: &schema.Schema{Type: schema.TypeString}, + Elem: &schema.Schema{ + Type: schema.TypeString, + ValidateFunc: validation.StringInSlice(lambda.Architecture_Values(), false), + }, }, "filename": { Type: schema.TypeString, From 95615cf62907510ea4f4d2306f8929fad88b8ee0 Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Wed, 8 Sep 2021 10:52:37 +0800 Subject: [PATCH 03/18] only update architectures when it is changed to non-empty value --- aws/resource_aws_lambda_function.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/aws/resource_aws_lambda_function.go b/aws/resource_aws_lambda_function.go index 86a8ee24cc3d..d6eb8dc828ea 100644 --- a/aws/resource_aws_lambda_function.go +++ b/aws/resource_aws_lambda_function.go @@ -1148,7 +1148,9 @@ func resourceAwsLambdaFunctionUpdate(d *schema.ResourceData, meta interface{}) e if d.HasChange("architectures") { architectures := d.Get("architectures").([]interface{}) - codeReq.Architectures = expandStringList(architectures) + if len(architectures) > 0 { + codeReq.Architectures = expandStringList(architectures) + } } if v, ok := d.GetOk("filename"); ok { From f1e8f9d09c1c807e3e4b853cde6f2696f9f48778 Mon Sep 17 00:00:00 2001 From: Randy Lin Date: Thu, 9 Sep 2021 01:50:45 +0800 Subject: [PATCH 04/18] add arm support for lambda layer --- aws/data_source_aws_lambda_layer_version.go | 20 +++++ ...ta_source_aws_lambda_layer_version_test.go | 75 +++++++++++++++++++ aws/resource_aws_lambda_layer_version.go | 19 +++++ aws/resource_aws_lambda_layer_version_test.go | 40 ++++++++++ 4 files changed, 154 insertions(+) diff --git a/aws/data_source_aws_lambda_layer_version.go b/aws/data_source_aws_lambda_layer_version.go index ecddb08eacf1..645aa97be89e 100644 --- a/aws/data_source_aws_lambda_layer_version.go +++ b/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.TypeList, + 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) } diff --git a/aws/data_source_aws_lambda_layer_version_test.go b/aws/data_source_aws_lambda_layer_version_test.go index 7b36d7171daf..fbcab97e2e71 100644 --- a/aws/data_source_aws_lambda_layer_version_test.go +++ b/aws/data_source_aws_lambda_layer_version_test.go @@ -82,6 +82,48 @@ func TestAccDataSourceAWSLambdaLayerVersion_runtime(t *testing.T) { }) } +func TestAccDataSourceAWSLambdaLayerVersion_architectures_x86(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"), + ), + }, + }, + }) +} + +func TestAccDataSourceAWSLambdaLayerVersion_architectures_arm(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: testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesARM(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,36 @@ 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) +} diff --git a/aws/resource_aws_lambda_layer_version.go b/aws/resource_aws_lambda_layer_version.go index 433a119a7229..f1b48ab7fff9 100644 --- a/aws/resource_aws_lambda_layer_version.go +++ b/aws/resource_aws_lambda_layer_version.go @@ -27,6 +27,17 @@ func resourceAwsLambdaLayerVersion() *schema.Resource { }, Schema: map[string]*schema.Schema{ + "compatible_architectures": { + Type: schema.TypeSet, + Optional: true, + ForceNew: true, + MinItems: 1, + MaxItems: 2, + Elem: &schema.Schema{ + Type: schema.TypeString, + ValidateFunc: validation.StringInSlice(lambda.Architecture_Values(), false), + }, + }, "layer_name": { Type: schema.TypeString, Required: true, @@ -165,6 +176,10 @@ func resourceAwsLambdaLayerVersionPublish(d *schema.ResourceData, meta interface params.CompatibleRuntimes = expandStringSet(v.(*schema.Set)) } + if v, ok := d.GetOk("compatible_architectures"); ok && v.(*schema.Set).Len() > 0 { + params.CompatibleArchitectures = expandStringSet(v.(*schema.Set)) + } + log.Printf("[DEBUG] Publishing Lambda layer: %s", params) result, err := conn.PublishLayerVersion(params) if err != nil { @@ -235,6 +250,10 @@ func resourceAwsLambdaLayerVersionRead(d *schema.ResourceData, meta interface{}) return fmt.Errorf("Error setting lambda layer compatible runtimes: %s", err) } + if err := d.Set("compatible_architectures", flattenStringList(layerVersion.CompatibleArchitectures)); err != nil { + return fmt.Errorf("Error setting lambda layer compatible architectures: %s", err) + } + return nil } diff --git a/aws/resource_aws_lambda_layer_version_test.go b/aws/resource_aws_lambda_layer_version_test.go index 9825bdd3981e..c799a752851d 100644 --- a/aws/resource_aws_lambda_layer_version_test.go +++ b/aws/resource_aws_lambda_layer_version_test.go @@ -185,6 +185,35 @@ func TestAccAWSLambdaLayerVersion_compatibleRuntimes(t *testing.T) { }) } +func TestAccAWSLambdaLayerVersion_compatibleArchitectures(t *testing.T) { + resourceName := "aws_lambda_layer_version.lambda_layer_test" + rString := acctest.RandString(8) + layerName := fmt.Sprintf("tf_acc_lambda_layer_architectures_%s", rString) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + ErrorCheck: testAccErrorCheck(t, lambda.EndpointsID), + Providers: testAccProviders, + CheckDestroy: testAccCheckLambdaLayerVersionDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSLambdaLayerVersionCompatibleArchitectures(layerName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaLayerVersionExists(resourceName, layerName), + resource.TestCheckResourceAttr(resourceName, "compatible_architectures.#", "2"), + ), + }, + + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"filename"}, + }, + }, + }) +} + func TestAccAWSLambdaLayerVersion_description(t *testing.T) { resourceName := "aws_lambda_layer_version.lambda_layer_test" rString := acctest.RandString(8) @@ -358,6 +387,17 @@ resource "aws_lambda_layer_version" "lambda_layer_test" { `, layerName) } +func testAccAWSLambdaLayerVersionCompatibleArchitectures(layerName string) string { + return fmt.Sprintf(` +resource "aws_lambda_layer_version" "lambda_layer_test" { + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" + + compatible_architectures = ["x86_64", "arm64"] +} +`, layerName) +} + func testAccAWSLambdaLayerVersionDescription(layerName string, description string) string { return fmt.Sprintf(` resource "aws_lambda_layer_version" "lambda_layer_test" { From 6d2d73f972daab3e15526de565c3cd0f5823487a Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Thu, 9 Sep 2021 10:49:46 +0800 Subject: [PATCH 05/18] Mark "architectures" as computed attribute. Add more test steps for updating architectures --- aws/resource_aws_lambda_function.go | 1 + aws/resource_aws_lambda_function_test.go | 29 ++++++++++++++++++++++-- 2 files changed, 28 insertions(+), 2 deletions(-) diff --git a/aws/resource_aws_lambda_function.go b/aws/resource_aws_lambda_function.go index d6eb8dc828ea..ba4c13ef3eae 100644 --- a/aws/resource_aws_lambda_function.go +++ b/aws/resource_aws_lambda_function.go @@ -50,6 +50,7 @@ func resourceAwsLambdaFunction() *schema.Resource { "architectures": { Type: schema.TypeList, Optional: true, + Computed: true, MaxItems: 1, Elem: &schema.Schema{ Type: schema.TypeString, diff --git a/aws/resource_aws_lambda_function_test.go b/aws/resource_aws_lambda_function_test.go index 28d4a59e8401..0b8cf2089987 100644 --- a/aws/resource_aws_lambda_function_test.go +++ b/aws/resource_aws_lambda_function_test.go @@ -95,6 +95,7 @@ func TestAccAWSLambdaFunction_basic(t *testing.T) { resource.TestCheckResourceAttr(resourceName, "reserved_concurrent_executions", "-1"), resource.TestCheckResourceAttr(resourceName, "version", LambdaFunctionVersionLatest), resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureX8664), testAccCheckResourceAttrRegionalARN(resourceName, "qualified_arn", "lambda", fmt.Sprintf("function:%s:%s", funcName, LambdaFunctionVersionLatest)), ), }, @@ -1024,7 +1025,19 @@ func TestAccAWSLambdaFunction_Architectures(t *testing.T) { testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), - resource.TestCheckResourceAttr(resourceName, "architectures.0", "arm64"), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureArm64), + ), + }, + // Ensure function's "architectures" attribute can be removed. The actual architecture remains unchanged. + { + Config: testAccAWSLambdaConfigBasic(funcName, policyName, roleName, sgName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), + testAccCheckAwsLambdaFunctionName(&conf, funcName), + testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), + testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), + resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureArm64), ), }, // Ensure configuration can be imported @@ -1043,7 +1056,19 @@ func TestAccAWSLambdaFunction_Architectures(t *testing.T) { testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), - resource.TestCheckResourceAttr(resourceName, "architectures.0", "x86_64"), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureX8664), + ), + }, + // Ensure function's "architectures" attribute can be removed. The actual architecture remains unchanged. + { + Config: testAccAWSLambdaConfigBasic(funcName, policyName, roleName, sgName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), + testAccCheckAwsLambdaFunctionName(&conf, funcName), + testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), + testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), + resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureX8664), ), }, }, From d05aacf817c38d3fdc52b8ef82929c88d107ac93 Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Thu, 9 Sep 2021 14:11:37 +0800 Subject: [PATCH 06/18] Update documents for Lambda function resource and data source. --- website/docs/d/lambda_function.html.markdown | 1 + website/docs/r/lambda_function.html.markdown | 1 + 2 files changed, 2 insertions(+) diff --git a/website/docs/d/lambda_function.html.markdown b/website/docs/d/lambda_function.html.markdown index a419a22c097f..6e895c7b2610 100644 --- a/website/docs/d/lambda_function.html.markdown +++ b/website/docs/d/lambda_function.html.markdown @@ -33,6 +33,7 @@ The following arguments are supported: In addition to all arguments above, the following attributes are exported: +* `architectures` - The instruction set architecture for the Lambda function. * `arn` - Unqualified (no `:QUALIFIER` or `:VERSION` suffix) Amazon Resource Name (ARN) identifying your Lambda Function. See also `qualified_arn`. * `code_signing_config_arn` - Amazon Resource Name (ARN) for a Code Signing Configuration. * `dead_letter_config` - Configure the function's *dead letter queue*. diff --git a/website/docs/r/lambda_function.html.markdown b/website/docs/r/lambda_function.html.markdown index f9266d2371b4..e32e15949860 100644 --- a/website/docs/r/lambda_function.html.markdown +++ b/website/docs/r/lambda_function.html.markdown @@ -214,6 +214,7 @@ The following arguments are required: The following arguments are optional: +* `architectures` - (Optional) Instruction set architecture for your Lambda function. Valid values are `["x86_64"]` and `["arm64"]`. Default is `["x86_64"]`. Removing this attribute, function's architecture stay the same. * `code_signing_config_arn` - (Optional) To enable code signing for this function, specify the ARN of a code-signing configuration. A code-signing configuration includes a set of signing profiles, which define the trusted publishers for this function. * `dead_letter_config` - (Optional) Configuration block. Detailed below. * `description` - (Optional) Description of what your Lambda Function does. From afbba5e9605af791d8a3e081e4a3812ffbc7b67e Mon Sep 17 00:00:00 2001 From: Randy Lin Date: Thu, 9 Sep 2021 15:33:31 +0800 Subject: [PATCH 07/18] Added test steps --- aws/data_source_aws_lambda_layer_version.go | 2 +- ...ta_source_aws_lambda_layer_version_test.go | 60 ++++++++++++++----- aws/resource_aws_lambda_layer_version.go | 1 - aws/resource_aws_lambda_layer_version_test.go | 56 ++++++++++++++++- 4 files changed, 100 insertions(+), 19 deletions(-) diff --git a/aws/data_source_aws_lambda_layer_version.go b/aws/data_source_aws_lambda_layer_version.go index 645aa97be89e..9128a0374171 100644 --- a/aws/data_source_aws_lambda_layer_version.go +++ b/aws/data_source_aws_lambda_layer_version.go @@ -81,7 +81,7 @@ func dataSourceAwsLambdaLayerVersion() *schema.Resource { ConflictsWith: []string{"version"}, }, "compatible_architectures": { - Type: schema.TypeList, + Type: schema.TypeSet, Computed: true, Elem: &schema.Schema{ Type: schema.TypeString, diff --git a/aws/data_source_aws_lambda_layer_version_test.go b/aws/data_source_aws_lambda_layer_version_test.go index fbcab97e2e71..af7b20468f31 100644 --- a/aws/data_source_aws_lambda_layer_version_test.go +++ b/aws/data_source_aws_lambda_layer_version_test.go @@ -82,7 +82,7 @@ func TestAccDataSourceAWSLambdaLayerVersion_runtime(t *testing.T) { }) } -func TestAccDataSourceAWSLambdaLayerVersion_architectures_x86(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" @@ -99,20 +99,6 @@ func TestAccDataSourceAWSLambdaLayerVersion_architectures_x86(t *testing.T) { resource.TestCheckResourceAttrPair(dataSourceName, "compatible_architectures", resourceName, "compatible_architectures"), ), }, - }, - }) -} - -func TestAccDataSourceAWSLambdaLayerVersion_architectures_arm(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: testAccDataSourceAWSLambdaLayerVersionConfigArchitecturesARM(rName), Check: resource.ComposeAggregateTestCheckFunc( @@ -120,6 +106,20 @@ func TestAccDataSourceAWSLambdaLayerVersion_architectures_arm(t *testing.T) { 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"), + ), + }, }, }) } @@ -212,3 +212,33 @@ data "aws_lambda_layer_version" "test" { } `, 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) +} diff --git a/aws/resource_aws_lambda_layer_version.go b/aws/resource_aws_lambda_layer_version.go index f1b48ab7fff9..5bdc2af4b52b 100644 --- a/aws/resource_aws_lambda_layer_version.go +++ b/aws/resource_aws_lambda_layer_version.go @@ -31,7 +31,6 @@ func resourceAwsLambdaLayerVersion() *schema.Resource { Type: schema.TypeSet, Optional: true, ForceNew: true, - MinItems: 1, MaxItems: 2, Elem: &schema.Schema{ Type: schema.TypeString, diff --git a/aws/resource_aws_lambda_layer_version_test.go b/aws/resource_aws_lambda_layer_version_test.go index c799a752851d..117247b9e8c7 100644 --- a/aws/resource_aws_lambda_layer_version_test.go +++ b/aws/resource_aws_lambda_layer_version_test.go @@ -197,7 +197,28 @@ func TestAccAWSLambdaLayerVersion_compatibleArchitectures(t *testing.T) { CheckDestroy: testAccCheckLambdaLayerVersionDestroy, Steps: []resource.TestStep{ { - Config: testAccAWSLambdaLayerVersionCompatibleArchitectures(layerName), + Config: testAccAWSLambdaLayerVersionCompatibleArchitecturesNone(layerName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaLayerVersionExists(resourceName, layerName), + resource.TestCheckResourceAttr(resourceName, "compatible_architectures.#", "0"), + ), + }, + { + Config: testAccAWSLambdaLayerVersionCompatibleArchitecturesX86(layerName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaLayerVersionExists(resourceName, layerName), + resource.TestCheckResourceAttr(resourceName, "compatible_architectures.#", "1"), + ), + }, + { + Config: testAccAWSLambdaLayerVersionCompatibleArchitecturesArm(layerName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaLayerVersionExists(resourceName, layerName), + resource.TestCheckResourceAttr(resourceName, "compatible_architectures.#", "1"), + ), + }, + { + Config: testAccAWSLambdaLayerVersionCompatibleArchitecturesX86Arm(layerName), Check: resource.ComposeTestCheckFunc( testAccCheckAwsLambdaLayerVersionExists(resourceName, layerName), resource.TestCheckResourceAttr(resourceName, "compatible_architectures.#", "2"), @@ -387,7 +408,16 @@ resource "aws_lambda_layer_version" "lambda_layer_test" { `, layerName) } -func testAccAWSLambdaLayerVersionCompatibleArchitectures(layerName string) string { +func testAccAWSLambdaLayerVersionCompatibleArchitecturesNone(layerName string) string { + return fmt.Sprintf(` +resource "aws_lambda_layer_version" "lambda_layer_test" { + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" +} +`, layerName) +} + +func testAccAWSLambdaLayerVersionCompatibleArchitecturesX86Arm(layerName string) string { return fmt.Sprintf(` resource "aws_lambda_layer_version" "lambda_layer_test" { filename = "test-fixtures/lambdatest.zip" @@ -398,6 +428,28 @@ resource "aws_lambda_layer_version" "lambda_layer_test" { `, layerName) } +func testAccAWSLambdaLayerVersionCompatibleArchitecturesX86(layerName string) string { + return fmt.Sprintf(` +resource "aws_lambda_layer_version" "lambda_layer_test" { + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" + + compatible_architectures = ["x86_64"] +} +`, layerName) +} + +func testAccAWSLambdaLayerVersionCompatibleArchitecturesArm(layerName string) string { + return fmt.Sprintf(` +resource "aws_lambda_layer_version" "lambda_layer_test" { + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" + + compatible_architectures = ["arm64"] +} +`, layerName) +} + func testAccAWSLambdaLayerVersionDescription(layerName string, description string) string { return fmt.Sprintf(` resource "aws_lambda_layer_version" "lambda_layer_test" { From 13d815e52d904adea544d9af8435ff6dfe1e3507 Mon Sep 17 00:00:00 2001 From: Randy Lin Date: Thu, 9 Sep 2021 15:37:37 +0800 Subject: [PATCH 08/18] Updated docs for architectures --- website/docs/d/lambda_layer_version.html.markdown | 2 ++ website/docs/r/lambda_layer_version.html.markdown | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/website/docs/d/lambda_layer_version.html.markdown b/website/docs/d/lambda_layer_version.html.markdown index dad69104d142..a45b721f7270 100644 --- a/website/docs/d/lambda_layer_version.html.markdown +++ b/website/docs/d/lambda_layer_version.html.markdown @@ -29,6 +29,7 @@ The following arguments are supported: * `layer_name` - (Required) Name of the lambda layer. * `version` - (Optional) Specific layer version. Conflicts with `compatible_runtime`. If omitted, the latest available layer version will be used. * `compatible_runtime` (Optional) Specific runtime the layer version must support. Conflicts with `version`. If specified, the latest available layer version supporting the provided runtime will be used. +* `compatible_architecture` (Optional) Specific architecture the layer version could support. Conflicts with `version`. If specified, the latest available layer version supporting the provided architecture will be used. ## Attributes Reference @@ -37,6 +38,7 @@ In addition to all arguments above, the following attributes are exported: * `description` - Description of the specific Lambda Layer version. * `license_info` - License info associated with the specific Lambda Layer version. * `compatible_runtimes` - A list of [Runtimes][1] the specific Lambda Layer version is compatible with. +* `compatible_architectures` - A list of [Architectures][2] the specific Lambda Layer version is compatible with. * `arn` - The Amazon Resource Name (ARN) of the Lambda Layer with version. * `layer_arn` - The Amazon Resource Name (ARN) of the Lambda Layer without version. * `created_date` - The date this resource was created. diff --git a/website/docs/r/lambda_layer_version.html.markdown b/website/docs/r/lambda_layer_version.html.markdown index 5737c9327fa2..7ac6b1129d7d 100644 --- a/website/docs/r/lambda_layer_version.html.markdown +++ b/website/docs/r/lambda_layer_version.html.markdown @@ -43,6 +43,7 @@ large files efficiently. * `s3_key` - (Optional) The S3 key of an object containing the function's deployment package. Conflicts with `filename`. * `s3_object_version` - (Optional) The object version containing the function's deployment package. Conflicts with `filename`. * `compatible_runtimes` - (Optional) A list of [Runtimes][2] this layer is compatible with. Up to 5 runtimes can be specified. +* `compatible_architectures` - (Optional) A list of [Architectures][4] this layer is compatible with. Currently `x86_64` and `arm64` can be specified. * `description` - (Optional) Description of what your Lambda Layer does. * `license_info` - (Optional) License info for your Lambda Layer. See [License Info][3]. * `source_code_hash` - (Optional) Used to trigger updates. Must be set to a base64-encoded SHA256 hash of the package file specified with either `filename` or `s3_key`. The usual way to set this is `${filebase64sha256("file.zip")}` (Terraform 0.11.12 or later) or `${base64sha256(file("file.zip"))}` (Terraform 0.11.11 and earlier), where "file.zip" is the local filename of the lambda layer source archive. @@ -57,7 +58,7 @@ In addition to all arguments above, the following attributes are exported: * `signing_job_arn` - The Amazon Resource Name (ARN) of a signing job. * `signing_profile_version_arn` - The Amazon Resource Name (ARN) for a signing profile version. * `source_code_size` - The size in bytes of the function .zip file. -* `version` - This Lamba Layer version. +* `version` - This Lambda Layer version. [1]: https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html [2]: https://docs.aws.amazon.com/lambda/latest/dg/API_PublishLayerVersion.html#SSS-PublishLayerVersion-request-CompatibleRuntimes From 8af1c2260941b7293e721a45aa7f8f16bbeddec1 Mon Sep 17 00:00:00 2001 From: Randy Lin Date: Thu, 9 Sep 2021 16:39:15 +0800 Subject: [PATCH 09/18] change format for test cases --- ...ta_source_aws_lambda_layer_version_test.go | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/aws/data_source_aws_lambda_layer_version_test.go b/aws/data_source_aws_lambda_layer_version_test.go index af7b20468f31..82cd2c3064d8 100644 --- a/aws/data_source_aws_lambda_layer_version_test.go +++ b/aws/data_source_aws_lambda_layer_version_test.go @@ -183,14 +183,14 @@ data "aws_lambda_layer_version" "test" { 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"] + 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 + layer_name = aws_lambda_layer_version.test.layer_name compatible_architecture = "x86_64" } @@ -200,14 +200,14 @@ data "aws_lambda_layer_version" "test" { 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"] + 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 + layer_name = aws_lambda_layer_version.test.layer_name compatible_architecture = "arm64" } `, rName) @@ -216,14 +216,14 @@ data "aws_lambda_layer_version" "test" { 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"] + 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 + layer_name = aws_lambda_layer_version.test.layer_name compatible_architecture = "arm64" } `, rName) From c92f57b5fb637308b79bf7994600ff93711d052c Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Thu, 9 Sep 2021 18:23:52 +0800 Subject: [PATCH 10/18] remove trailing space --- website/docs/d/lambda_function.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/website/docs/d/lambda_function.html.markdown b/website/docs/d/lambda_function.html.markdown index 6e895c7b2610..57d9c894c8ca 100644 --- a/website/docs/d/lambda_function.html.markdown +++ b/website/docs/d/lambda_function.html.markdown @@ -33,7 +33,7 @@ The following arguments are supported: In addition to all arguments above, the following attributes are exported: -* `architectures` - The instruction set architecture for the Lambda function. +* `architectures` - The instruction set architecture for the Lambda function. * `arn` - Unqualified (no `:QUALIFIER` or `:VERSION` suffix) Amazon Resource Name (ARN) identifying your Lambda Function. See also `qualified_arn`. * `code_signing_config_arn` - Amazon Resource Name (ARN) for a Code Signing Configuration. * `dead_letter_config` - Configure the function's *dead letter queue*. From aa58c2ced820cca805f901567b4f0b0d35dd54c5 Mon Sep 17 00:00:00 2001 From: Randy Lin Date: Thu, 9 Sep 2021 23:49:59 +0800 Subject: [PATCH 11/18] fix format issue --- aws/data_source_aws_lambda_layer_version_test.go | 10 +++++----- aws/resource_aws_lambda_layer_version_test.go | 15 ++++++--------- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/aws/data_source_aws_lambda_layer_version_test.go b/aws/data_source_aws_lambda_layer_version_test.go index 82cd2c3064d8..2e3ed1f90f68 100644 --- a/aws/data_source_aws_lambda_layer_version_test.go +++ b/aws/data_source_aws_lambda_layer_version_test.go @@ -191,7 +191,7 @@ resource "aws_lambda_layer_version" "test" { data "aws_lambda_layer_version" "test" { layer_name = aws_lambda_layer_version.test.layer_name - compatible_architecture = "x86_64" + compatible_architecture = "x86_64" } `, rName) @@ -208,7 +208,7 @@ resource "aws_lambda_layer_version" "test" { data "aws_lambda_layer_version" "test" { layer_name = aws_lambda_layer_version.test.layer_name - compatible_architecture = "arm64" + compatible_architecture = "arm64" } `, rName) } @@ -223,8 +223,8 @@ resource "aws_lambda_layer_version" "test" { } data "aws_lambda_layer_version" "test" { - layer_name = aws_lambda_layer_version.test.layer_name - compatible_architecture = "arm64" + layer_name = aws_lambda_layer_version.test.layer_name + compatible_architecture = "arm64" } `, rName) } @@ -238,7 +238,7 @@ resource "aws_lambda_layer_version" "test" { } data "aws_lambda_layer_version" "test" { - layer_name = aws_lambda_layer_version.test.layer_name + layer_name = aws_lambda_layer_version.test.layer_name } `, rName) } diff --git a/aws/resource_aws_lambda_layer_version_test.go b/aws/resource_aws_lambda_layer_version_test.go index 117247b9e8c7..d0baf6dd9e15 100644 --- a/aws/resource_aws_lambda_layer_version_test.go +++ b/aws/resource_aws_lambda_layer_version_test.go @@ -420,9 +420,8 @@ resource "aws_lambda_layer_version" "lambda_layer_test" { func testAccAWSLambdaLayerVersionCompatibleArchitecturesX86Arm(layerName string) string { return fmt.Sprintf(` resource "aws_lambda_layer_version" "lambda_layer_test" { - filename = "test-fixtures/lambdatest.zip" - layer_name = "%s" - + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" compatible_architectures = ["x86_64", "arm64"] } `, layerName) @@ -431,9 +430,8 @@ resource "aws_lambda_layer_version" "lambda_layer_test" { func testAccAWSLambdaLayerVersionCompatibleArchitecturesX86(layerName string) string { return fmt.Sprintf(` resource "aws_lambda_layer_version" "lambda_layer_test" { - filename = "test-fixtures/lambdatest.zip" - layer_name = "%s" - + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" compatible_architectures = ["x86_64"] } `, layerName) @@ -442,9 +440,8 @@ resource "aws_lambda_layer_version" "lambda_layer_test" { func testAccAWSLambdaLayerVersionCompatibleArchitecturesArm(layerName string) string { return fmt.Sprintf(` resource "aws_lambda_layer_version" "lambda_layer_test" { - filename = "test-fixtures/lambdatest.zip" - layer_name = "%s" - + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" compatible_architectures = ["arm64"] } `, layerName) From a6161ee4de05cd05872d9c066803c9dcfa1c7a7f Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Fri, 10 Sep 2021 11:53:49 +0800 Subject: [PATCH 12/18] add a test case for an arm function with a compatible layer --- aws/resource_aws_lambda_function_test.go | 95 ++++++++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/aws/resource_aws_lambda_function_test.go b/aws/resource_aws_lambda_function_test.go index 0b8cf2089987..f88aac64f5e9 100644 --- a/aws/resource_aws_lambda_function_test.go +++ b/aws/resource_aws_lambda_function_test.go @@ -1073,7 +1073,60 @@ func TestAccAWSLambdaFunction_Architectures(t *testing.T) { }, }, }) +} + +func TestAccAWSLambdaFunction_ArchitecturesWithLayer(t *testing.T) { + var conf lambda.GetFunctionOutput + resourceName := "aws_lambda_function.test" + + rString := acctest.RandString(8) + funcName := fmt.Sprintf("tf_acc_lambda_func_basic_%s", rString) + layerName := fmt.Sprintf("tf_acc_lambda_layer_%s", rString) + policyName := fmt.Sprintf("tf_acc_policy_lambda_func_basic_%s", rString) + roleName := fmt.Sprintf("tf_acc_role_lambda_func_basic_%s", rString) + sgName := fmt.Sprintf("tf_acc_sg_lambda_func_basic_%s", rString) + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + ErrorCheck: testAccErrorCheck(t, lambda.EndpointsID), + Providers: testAccProviders, + CheckDestroy: testAccCheckLambdaFunctionDestroy, + Steps: []resource.TestStep{ + // Ensure function with arm64 architecture can be created + { + Config: testAccAWSLambdaArchitecturesARM64WithLayer(funcName, layerName, policyName, roleName, sgName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), + testAccCheckAwsLambdaFunctionName(&conf, funcName), + testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), + testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), + resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureArm64), + resource.TestCheckResourceAttr(resourceName, "layers.#", "1"), + ), + }, + // Ensure configuration can be imported + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"filename", "publish"}, + }, + // Ensure function architecture can be updated + { + Config: testAccAWSLambdaArchitecturesUpdateWithLayer(funcName, layerName, policyName, roleName, sgName), + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), + testAccCheckAwsLambdaFunctionName(&conf, funcName), + testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), + testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), + resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureX8664), + resource.TestCheckResourceAttr(resourceName, "layers.#", "1"), + ), + }, + }, + }) } func TestAccAWSLambdaFunction_tracingConfig(t *testing.T) { @@ -2811,6 +2864,48 @@ resource "aws_lambda_function" "test" { `, funcName) } +func testAccAWSLambdaArchitecturesARM64WithLayer(funcName, layerName, policyName, roleName, sgName string) string { + return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` +resource "aws_lambda_layer_version" "test" { + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" + compatible_runtimes = ["nodejs12.x"] + compatible_architectures = ["arm64", "x86_64"] +} + +resource "aws_lambda_function" "test" { + filename = "test-fixtures/lambdatest.zip" + function_name = "%s" + role = aws_iam_role.iam_for_lambda.arn + handler = "exports.example" + runtime = "nodejs12.x" + architectures = ["arm64"] + layers = [aws_lambda_layer_version.test.arn] +} +`, layerName, funcName) +} + +func testAccAWSLambdaArchitecturesUpdateWithLayer(funcName, layerName, policyName, roleName, sgName string) string { + return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` +resource "aws_lambda_layer_version" "test" { + filename = "test-fixtures/lambdatest.zip" + layer_name = "%s" + compatible_runtimes = ["nodejs12.x"] + compatible_architectures = ["arm64", "x86_64"] +} + +resource "aws_lambda_function" "test" { + filename = "test-fixtures/lambdatest.zip" + function_name = "%s" + role = aws_iam_role.iam_for_lambda.arn + handler = "exports.example" + runtime = "nodejs12.x" + architectures = ["x86_64"] + layers = [aws_lambda_layer_version.test.arn] +} +`, layerName, funcName) +} + func testAccAWSLambdaConfigVersionedNodeJs10xRuntime(fileName, funcName, policyName, roleName, sgName string) string { return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` resource "aws_lambda_function" "test" { From a2f2423cccca9c45a1fef4a2ac01fca0648b185b Mon Sep 17 00:00:00 2001 From: Randy Lin <35800534+linjungz@users.noreply.github.com> Date: Sat, 18 Sep 2021 13:25:00 +0800 Subject: [PATCH 13/18] Update aws/resource_aws_lambda_layer_version_test.go Co-authored-by: Graham Davison --- aws/resource_aws_lambda_layer_version_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/aws/resource_aws_lambda_layer_version_test.go b/aws/resource_aws_lambda_layer_version_test.go index d0baf6dd9e15..27df3c837cd7 100644 --- a/aws/resource_aws_lambda_layer_version_test.go +++ b/aws/resource_aws_lambda_layer_version_test.go @@ -208,6 +208,7 @@ func TestAccAWSLambdaLayerVersion_compatibleArchitectures(t *testing.T) { Check: resource.ComposeTestCheckFunc( testAccCheckAwsLambdaLayerVersionExists(resourceName, layerName), resource.TestCheckResourceAttr(resourceName, "compatible_architectures.#", "1"), + resource.TestCheckTypeSetElemAttr(resourceName, "compatible_architectures.*", lambda.ArchitectureX8664), ), }, { From c8630462625dcb28612e0092771555c0525f3897 Mon Sep 17 00:00:00 2001 From: Randy Lin <35800534+linjungz@users.noreply.github.com> Date: Sat, 18 Sep 2021 13:30:26 +0800 Subject: [PATCH 14/18] Update website/docs/d/lambda_layer_version.html.markdown Co-authored-by: Graham Davison --- website/docs/d/lambda_layer_version.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/website/docs/d/lambda_layer_version.html.markdown b/website/docs/d/lambda_layer_version.html.markdown index a45b721f7270..33d715c4b49b 100644 --- a/website/docs/d/lambda_layer_version.html.markdown +++ b/website/docs/d/lambda_layer_version.html.markdown @@ -27,7 +27,7 @@ data "aws_lambda_layer_version" "existing" { The following arguments are supported: * `layer_name` - (Required) Name of the lambda layer. -* `version` - (Optional) Specific layer version. Conflicts with `compatible_runtime`. If omitted, the latest available layer version will be used. +* `version` - (Optional) Specific layer version. Conflicts with `compatible_runtime` and `compatible_architecture`. If omitted, the latest available layer version will be used. * `compatible_runtime` (Optional) Specific runtime the layer version must support. Conflicts with `version`. If specified, the latest available layer version supporting the provided runtime will be used. * `compatible_architecture` (Optional) Specific architecture the layer version could support. Conflicts with `version`. If specified, the latest available layer version supporting the provided architecture will be used. From 2860d72b585a678ebeb37eb47c9706b13a3ed8e3 Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Sat, 18 Sep 2021 21:11:13 +0800 Subject: [PATCH 15/18] update testcases based on review feedback --- aws/resource_aws_lambda_function_test.go | 63 ++++++++++++++++++------ 1 file changed, 47 insertions(+), 16 deletions(-) diff --git a/aws/resource_aws_lambda_function_test.go b/aws/resource_aws_lambda_function_test.go index f88aac64f5e9..33f2b01ae89e 100644 --- a/aws/resource_aws_lambda_function_test.go +++ b/aws/resource_aws_lambda_function_test.go @@ -1025,9 +1025,17 @@ func TestAccAWSLambdaFunction_Architectures(t *testing.T) { testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.#", "1"), resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureArm64), ), }, + // Ensure configuration can be imported + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"filename", "publish"}, + }, // Ensure function's "architectures" attribute can be removed. The actual architecture remains unchanged. { Config: testAccAWSLambdaConfigBasic(funcName, policyName, roleName, sgName), @@ -1037,37 +1045,60 @@ func TestAccAWSLambdaFunction_Architectures(t *testing.T) { testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.#", "1"), resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureArm64), ), }, - // Ensure configuration can be imported - { - ResourceName: resourceName, - ImportState: true, - ImportStateVerify: true, - ImportStateVerifyIgnore: []string{"filename", "publish"}, - }, - // Ensure function architecture can be updated + }, + }) +} + +func TestAccAWSLambdaFunction_ArchitecturesUpdate(t *testing.T) { + var conf lambda.GetFunctionOutput + resourceName := "aws_lambda_function.test" + + rString := acctest.RandString(8) + funcName := fmt.Sprintf("tf_acc_lambda_func_basic_%s", rString) + policyName := fmt.Sprintf("tf_acc_policy_lambda_func_basic_%s", rString) + roleName := fmt.Sprintf("tf_acc_role_lambda_func_basic_%s", rString) + sgName := fmt.Sprintf("tf_acc_sg_lambda_func_basic_%s", rString) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + ErrorCheck: testAccErrorCheck(t, lambda.EndpointsID), + Providers: testAccProviders, + CheckDestroy: testAccCheckLambdaFunctionDestroy, + Steps: []resource.TestStep{ + // Ensure function with arm64 architecture can be created { - Config: testAccAWSLambdaArchitecturesUpdate(funcName, policyName, roleName, sgName), + Config: testAccAWSLambdaArchitecturesARM64(funcName, policyName, roleName, sgName), Check: resource.ComposeTestCheckFunc( testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), testAccCheckAwsLambdaFunctionName(&conf, funcName), testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), - resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureX8664), + resource.TestCheckResourceAttr(resourceName, "architectures.#", "1"), + resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureArm64), ), }, - // Ensure function's "architectures" attribute can be removed. The actual architecture remains unchanged. + // Ensure configuration can be imported { - Config: testAccAWSLambdaConfigBasic(funcName, policyName, roleName, sgName), + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"filename", "publish"}, + }, + // Ensure function architecture can be updated + { + Config: testAccAWSLambdaArchitecturesUpdate(funcName, policyName, roleName, sgName), Check: resource.ComposeTestCheckFunc( testAccCheckAwsLambdaFunctionExists(resourceName, funcName, &conf), testAccCheckAwsLambdaFunctionName(&conf, funcName), testAccCheckResourceAttrRegionalARN(resourceName, "arn", "lambda", fmt.Sprintf("function:%s", funcName)), testAccCheckAwsLambdaFunctionInvokeArn(resourceName, &conf), resource.TestCheckResourceAttr(resourceName, "package_type", lambda.PackageTypeZip), + resource.TestCheckResourceAttr(resourceName, "architectures.#", "1"), resource.TestCheckResourceAttr(resourceName, "architectures.0", lambda.ArchitectureX8664), ), }, @@ -2868,14 +2899,14 @@ func testAccAWSLambdaArchitecturesARM64WithLayer(funcName, layerName, policyName return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` resource "aws_lambda_layer_version" "test" { filename = "test-fixtures/lambdatest.zip" - layer_name = "%s" + layer_name = "%[1]s" compatible_runtimes = ["nodejs12.x"] compatible_architectures = ["arm64", "x86_64"] } resource "aws_lambda_function" "test" { filename = "test-fixtures/lambdatest.zip" - function_name = "%s" + function_name = "%[2]s" role = aws_iam_role.iam_for_lambda.arn handler = "exports.example" runtime = "nodejs12.x" @@ -2889,14 +2920,14 @@ func testAccAWSLambdaArchitecturesUpdateWithLayer(funcName, layerName, policyNam return fmt.Sprintf(baseAccAWSLambdaConfig(policyName, roleName, sgName)+` resource "aws_lambda_layer_version" "test" { filename = "test-fixtures/lambdatest.zip" - layer_name = "%s" + layer_name = "%[1]s" compatible_runtimes = ["nodejs12.x"] compatible_architectures = ["arm64", "x86_64"] } resource "aws_lambda_function" "test" { filename = "test-fixtures/lambdatest.zip" - function_name = "%s" + function_name = "%[2]s" role = aws_iam_role.iam_for_lambda.arn handler = "exports.example" runtime = "nodejs12.x" From 6b1db743092060590a4c2440ccfcb2aaa01a0327 Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Thu, 30 Sep 2021 06:24:26 +0800 Subject: [PATCH 16/18] add Link to Lambda API doc --- website/docs/r/lambda_layer_version.html.markdown | 1 + 1 file changed, 1 insertion(+) diff --git a/website/docs/r/lambda_layer_version.html.markdown b/website/docs/r/lambda_layer_version.html.markdown index 7ac6b1129d7d..3ed205daf98f 100644 --- a/website/docs/r/lambda_layer_version.html.markdown +++ b/website/docs/r/lambda_layer_version.html.markdown @@ -63,6 +63,7 @@ In addition to all arguments above, the following attributes are exported: [1]: https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html [2]: https://docs.aws.amazon.com/lambda/latest/dg/API_PublishLayerVersion.html#SSS-PublishLayerVersion-request-CompatibleRuntimes [3]: https://docs.aws.amazon.com/lambda/latest/dg/API_PublishLayerVersion.html#SSS-PublishLayerVersion-request-LicenseInfo +[4]: https://docs.aws.amazon.com/lambda/latest/dg/API_PublishLayerVersion.html#SSS-PublishLayerVersion-request-CompatibleArchitectures ## Import From 7ce15e7c042366d420005dc93808bba874ec5d96 Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Thu, 30 Sep 2021 07:04:52 +0800 Subject: [PATCH 17/18] add Link to Lambda API doc --- website/docs/d/lambda_layer_version.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/website/docs/d/lambda_layer_version.html.markdown b/website/docs/d/lambda_layer_version.html.markdown index 33d715c4b49b..d9567e6d9a05 100644 --- a/website/docs/d/lambda_layer_version.html.markdown +++ b/website/docs/d/lambda_layer_version.html.markdown @@ -49,4 +49,4 @@ In addition to all arguments above, the following attributes are exported: * `version` - This Lamba Layer version. [1]: https://docs.aws.amazon.com/lambda/latest/dg/API_GetLayerVersion.html#SSS-GetLayerVersion-response-CompatibleRuntimes - +[2]: https://docs.aws.amazon.com/lambda/latest/dg/API_GetLayerVersion.html#SSS-GetLayerVersion-response-CompatibleArchitectures From 999126609167d069d043fce5c11e80445e840d7a Mon Sep 17 00:00:00 2001 From: Harold Sun Date: Thu, 30 Sep 2021 08:30:07 +0800 Subject: [PATCH 18/18] add CHANGELOG file --- .changelog/21091.txt | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 .changelog/21091.txt diff --git a/.changelog/21091.txt b/.changelog/21091.txt new file mode 100644 index 000000000000..23222890d135 --- /dev/null +++ b/.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 +```