Add lambda container image support

aws/resource_aws_lambda_function.go

@@ -14,6 +14,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/endpoints"
 	"github.com/aws/aws-sdk-go/service/lambda"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/customdiff"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
@@ -47,22 +48,57 @@ func resourceAwsLambdaFunction() *schema.Resource {
 			"filename": {
 				Type:          schema.TypeString,
 				Optional:      true,
-				ConflictsWith: []string{"s3_bucket", "s3_key", "s3_object_version"},
+				ConflictsWith: []string{"s3_bucket", "s3_key", "s3_object_version", "image_uri"},
 			},
 			"s3_bucket": {
 				Type:          schema.TypeString,
 				Optional:      true,
-				ConflictsWith: []string{"filename"},
+				ConflictsWith: []string{"filename", "image_uri"},
 			},
 			"s3_key": {
 				Type:          schema.TypeString,
 				Optional:      true,
-				ConflictsWith: []string{"filename"},
+				ConflictsWith: []string{"filename", "image_uri"},
 			},
 			"s3_object_version": {
 				Type:          schema.TypeString,
 				Optional:      true,
-				ConflictsWith: []string{"filename"},
+				ConflictsWith: []string{"filename", "image_uri"},
+			},
+			"image_uri": {
+				Type:          schema.TypeString,
+				Optional:      true,
+				ConflictsWith: []string{"filename", "s3_bucket", "s3_key", "s3_object_version"},
+			},
+			"package_type": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ForceNew:     true,
+				Default:      lambda.PackageTypeZip,
+				ValidateFunc: validation.StringInSlice(lambda.PackageType_Values(), false),
+			},
+			"image_config": {
+				Type:     schema.TypeList,
+				Optional: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"entry_point": {
+							Type:     schema.TypeList,
+							Optional: true,
+							Elem:     &schema.Schema{Type: schema.TypeString},
+						},
+						"command": {
+							Type:     schema.TypeList,
+							Optional: true,
+							Elem:     &schema.Schema{Type: schema.TypeString},
+						},
+						"working_directory": {
+							Type:     schema.TypeString,
+							Optional: true,
+						},
+					},
+				},
 			},
 			"code_signing_config_arn": {
 				Type:         schema.TypeString,
@@ -126,7 +162,7 @@ func resourceAwsLambdaFunction() *schema.Resource {
 			},
 			"handler": {
 				Type:         schema.TypeString,
-				Required:     true,
+				Optional:     true,
 				ValidateFunc: validation.StringLenBetween(1, 128),
 			},
 			"layers": {
@@ -155,7 +191,7 @@ func resourceAwsLambdaFunction() *schema.Resource {
 			},
 			"runtime": {
 				Type:         schema.TypeString,
-				Required:     true,
+				Optional:     true,
 				ValidateFunc: validation.StringInSlice(lambda.Runtime_Values(), false),
 			},
 			"timeout": {
@@ -280,10 +316,24 @@ func resourceAwsLambdaFunction() *schema.Resource {
 			"tags": tagsSchema(),
 		},
 
-		CustomizeDiff: updateComputedAttributesOnPublish,
+		CustomizeDiff: customdiff.Sequence(
+			checkHandlerRuntimeForZipFunction,
+			updateComputedAttributesOnPublish,
+		),
 	}
 }
 
+func checkHandlerRuntimeForZipFunction(_ context.Context, d *schema.ResourceDiff, meta interface{}) error {
+	packageType := d.Get("package_type")
+	_, handlerOk := d.GetOk("handler")
+	_, runtimeOk := d.GetOk("runtime")
+
+	if packageType == lambda.PackageTypeZip && !handlerOk && !runtimeOk {
+		return fmt.Errorf("handler and runtime must be set when PackageType is Zip")
+	}
+	return nil
+}
+
 func updateComputedAttributesOnPublish(_ context.Context, d *schema.ResourceDiff, meta interface{}) error {
 	configChanged := hasConfigChanges(d)
 	functionCodeUpdated := needsFunctionCodeUpdate(d)
@@ -304,6 +354,7 @@ func hasConfigChanges(d resourceDiffer) bool {
 	return d.HasChange("description") ||
 		d.HasChange("handler") ||
 		d.HasChange("file_system_config") ||
+		d.HasChange("image_config") ||
 		d.HasChange("memory_size") ||
 		d.HasChange("role") ||
 		d.HasChange("timeout") ||
@@ -331,9 +382,10 @@ func resourceAwsLambdaFunctionCreate(d *schema.ResourceData, meta interface{}) e
 	s3Bucket, bucketOk := d.GetOk("s3_bucket")
 	s3Key, keyOk := d.GetOk("s3_key")
 	s3ObjectVersion, versionOk := d.GetOk("s3_object_version")
+	imageUri, hasImageUri := d.GetOk("image_uri")
 
-	if !hasFilename && !bucketOk && !keyOk && !versionOk {
-		return errors.New("filename or s3_* attributes must be set")
+	if !hasFilename && !bucketOk && !keyOk && !versionOk && !hasImageUri {
+		return errors.New("filename, s3_* or image_uri attributes must be set")
 	}
 
 	var functionCode *lambda.FunctionCode
@@ -350,6 +402,10 @@ func resourceAwsLambdaFunctionCreate(d *schema.ResourceData, meta interface{}) e
 		functionCode = &lambda.FunctionCode{
 			ZipFile: file,
 		}
+	} else if hasImageUri {
+		functionCode = &lambda.FunctionCode{
+			ImageUri: aws.String(imageUri.(string)),
+		}
 	} else {
 		if !bucketOk || !keyOk {
 			return errors.New("s3_bucket and s3_key must all be set while using S3 code source")
@@ -363,16 +419,28 @@ func resourceAwsLambdaFunctionCreate(d *schema.ResourceData, meta interface{}) e
 		}
 	}
 
+	packageType := d.Get("package_type")
+	handler, handlerOk := d.GetOk("handler")
+	runtime, runtimeOk := d.GetOk("runtime")
+
+	if packageType == lambda.PackageTypeZip && !handlerOk && !runtimeOk {
+		return errors.New("handler and runtime must be set when PackageType is Zip")
+	}
+
 	params := &lambda.CreateFunctionInput{
 		Code:         functionCode,
 		Description:  aws.String(d.Get("description").(string)),
 		FunctionName: aws.String(functionName),
-		Handler:      aws.String(d.Get("handler").(string)),
 		MemorySize:   aws.Int64(int64(d.Get("memory_size").(int))),
 		Role:         aws.String(iamRole),
-		Runtime:      aws.String(d.Get("runtime").(string)),
 		Timeout:      aws.Int64(int64(d.Get("timeout").(int))),
 		Publish:      aws.Bool(d.Get("publish").(bool)),
+		PackageType:  aws.String(d.Get("package_type").(string)),
+	}
+
+	if packageType == lambda.PackageTypeZip {
+		params.Handler = aws.String(handler.(string))
+		params.Runtime = aws.String(runtime.(string))
 	}
 
 	if v, ok := d.GetOk("code_signing_config_arn"); ok {
@@ -401,6 +469,10 @@ func resourceAwsLambdaFunctionCreate(d *schema.ResourceData, meta interface{}) e
 		params.FileSystemConfigs = expandLambdaFileSystemConfigs(v.([]interface{}))
 	}
 
+	if v, ok := d.GetOk("image_config"); ok && len(v.([]interface{})) > 0 {
+		params.ImageConfig = expandLambdaImageConfigs(v.([]interface{}))
+	}
+
 	if v, ok := d.GetOk("vpc_config"); ok && len(v.([]interface{})) > 0 {
 		config := v.([]interface{})[0].(map[string]interface{})
 
@@ -641,6 +713,23 @@ func resourceAwsLambdaFunctionRead(d *schema.ResourceData, meta interface{}) err
 		return fmt.Errorf("Error setting file system config for Lambda Function (%s): %w", d.Id(), err)
 	}
 
+	// Add Package Type
+	log.Printf("[INFO] Setting Lambda %s package type %#v from API", d.Id(), function.PackageType)
+	if err := d.Set("package_type", function.PackageType); err != nil {
+		return fmt.Errorf("Error setting package type for Lambda Function: %w", err)
+	}
+
+	// Add Image Configuration
+	imageConfig := flattenLambdaImageConfig(function.ImageConfigResponse)
+	log.Printf("[INFO] Setting Lambda %s Image config %#v from API", d.Id(), imageConfig)
+	if err := d.Set("image_config", imageConfig); err != nil {
+		return fmt.Errorf("Error setting image config for Lambda Function: %s", err)
+	}
+
+	if err := d.Set("image_uri", getFunctionOutput.Code.ImageUri); err != nil {
+		return fmt.Errorf("Error setting image uri for Lambda Function: %s", err)
+	}
+
 	layers := flattenLambdaLayers(function.Layers)
 	log.Printf("[INFO] Setting Lambda %s Layers %#v from API", d.Id(), layers)
 	if err := d.Set("layers", layers); err != nil {
@@ -723,15 +812,20 @@ func resourceAwsLambdaFunctionRead(d *schema.ResourceData, meta interface{}) err
 		FunctionName: aws.String(d.Get("function_name").(string)),
 	}
 
-	getCodeSigningConfigOutput, err := conn.GetFunctionCodeSigningConfig(codeSigningConfigInput)
-	if err != nil {
-		return fmt.Errorf("error getting Lambda Function (%s) code signing config %w", d.Id(), err)
-	}
+	// Code Signing is only supported on zip packaged lambda functions.
+	if *function.PackageType == lambda.PackageTypeZip {
+		getCodeSigningConfigOutput, err := conn.GetFunctionCodeSigningConfig(codeSigningConfigInput)
+		if err != nil {
+			return fmt.Errorf("error getting Lambda Function (%s) code signing config %w", d.Id(), err)
+		}
 
-	if getCodeSigningConfigOutput == nil || getCodeSigningConfigOutput.CodeSigningConfigArn == nil {
-		d.Set("code_signing_config_arn", "")
+		if getCodeSigningConfigOutput == nil || getCodeSigningConfigOutput.CodeSigningConfigArn == nil {
+			d.Set("code_signing_config_arn", "")
+		} else {
+			d.Set("code_signing_config_arn", getCodeSigningConfigOutput.CodeSigningConfigArn)
+		}
 	} else {
-		d.Set("code_signing_config_arn", getCodeSigningConfigOutput.CodeSigningConfigArn)
+		d.Set("code_signing_config_arn", "")
 	}
 
 	return nil
@@ -779,7 +873,9 @@ func needsFunctionCodeUpdate(d resourceDiffer) bool {
 		d.HasChange("source_code_hash") ||
 		d.HasChange("s3_bucket") ||
 		d.HasChange("s3_key") ||
-		d.HasChange("s3_object_version")
+		d.HasChange("s3_object_version") ||
+		d.HasChange("image_uri")
+
 }
 
 // resourceAwsLambdaFunctionUpdate maps to:
@@ -840,6 +936,12 @@ func resourceAwsLambdaFunctionUpdate(d *schema.ResourceData, meta interface{}) e
 			configReq.FileSystemConfigs = expandLambdaFileSystemConfigs(v.([]interface{}))
 		}
 	}
+	if d.HasChange("image_config") {
+		configReq.ImageConfig = &lambda.ImageConfig{}
+		if v, ok := d.GetOk("image_config"); ok && len(v.([]interface{})) > 0 {
+			configReq.ImageConfig = expandLambdaImageConfigs(v.([]interface{}))
+		}
+	}
 	if d.HasChange("memory_size") {
 		configReq.MemorySize = aws.Int64(int64(d.Get("memory_size").(int)))
 	}
@@ -990,6 +1092,8 @@ func resourceAwsLambdaFunctionUpdate(d *schema.ResourceData, meta interface{}) e
 				return fmt.Errorf("Unable to load %q: %w", v.(string), err)
 			}
 			codeReq.ZipFile = file
+		} else if v, ok := d.GetOk("image_uri"); ok {
+			codeReq.ImageUri = aws.String(v.(string))
 		} else {
 			s3Bucket, _ := d.GetOk("s3_bucket")
 			s3Key, _ := d.GetOk("s3_key")
@@ -1188,3 +1292,33 @@ func expandLambdaFileSystemConfigs(fscMaps []interface{}) []*lambda.FileSystemCo
 	}
 	return fileSystemConfigs
 }
+
+func flattenLambdaImageConfig(response *lambda.ImageConfigResponse) []map[string]interface{} {
+	settings := make(map[string]interface{})
+
+	if response == nil || response.Error != nil {
+		return nil
+	}
+
+	settings["command"] = response.ImageConfig.Command
+	settings["entry_point"] = response.ImageConfig.EntryPoint
+	settings["working_directory"] = response.ImageConfig.WorkingDirectory
+
+	return []map[string]interface{}{settings}
+}
+
+func expandLambdaImageConfigs(imageConfigMaps []interface{}) *lambda.ImageConfig {
+	imageConfig := &lambda.ImageConfig{}
+	// only one image_config block is allowed
+	if len(imageConfigMaps) == 1 && imageConfigMaps[0] != nil {
+		config := imageConfigMaps[0].(map[string]interface{})
+		if len(config["entry_point"].([]interface{})) > 0 {
+			imageConfig.EntryPoint = expandStringList(config["entry_point"].([]interface{}))
+		}
+		if len(config["command"].([]interface{})) > 0 {
+			imageConfig.Command = expandStringList(config["command"].([]interface{}))
+		}
+		imageConfig.WorkingDirectory = aws.String(config["working_directory"].(string))
+	}
+	return imageConfig
+}