A Comprehensive Guide to Mastering Terraform Lambda Modules

A DevOps team at a growing company needed to handle automation and event-driven responses across multiple applications. Managing numerous Lambda functions individually became unwieldy. Terraform provided a way to solve this problem.

What is Terraform?

Terraform is an open-source IaC tool that lets you define infrastructure using configuration files in HashiCorp Configuration Language (HCL). Teams manage infrastructure code with version control and automated testing, similar to application code.

Why Use a Terraform Module?

Reusable modules in Terraform provide several benefits:

1. Consistency: The same configuration works across different environments.
2. Maintainability: Updates need to happen in only one place.
3. Efficiency: Developers spend less time on boilerplate code.

Getting Started with Your First Lambda Module

To create your first Lambda module:

module "lambda_function" {
  source = "terraform-aws-modules/lambda/aws"

  function_name = "my_lambda_function"
  handler       = "index.handler"
  runtime       = "nodejs20.x"

  environment_variables = {
    SOME_ENVIRONMENT_VARIABLE = "some_value"
  }
}

Trade-offs

As modules grow in capability, consider these trade-offs:

1. Complexity: Larger modules can become harder to maintain.
2. Flexibility: Highly configurable modules may lead to over-engineering, making them less suitable for specific use cases.

Expanding Your Module from Simple to Complex

As project requirements evolve, you may need to expand your module’s capabilities. Here is an example that adds VPC support:

module "lambda_function" {
  source = "terraform-aws-modules/lambda/aws"

  function_name = "my_lambda_function"
  handler       = "index.handler"
  runtime       = "nodejs20.x"

  # VPC support
  vpc_subnet_ids         = ["subnet-12345678", "subnet-87654321"]
  vpc_security_group_ids = ["sg-12345678"]

  environment_variables = {
    SOME_ENVIRONMENT_VARIABLE = "some_value"
  }
}

Limitations

Terraform has some limitations when managing Lambda functions:

1. Provider-specific features: Some AWS Lambda settings may not be supported by the Terraform provider. In these cases, you may need AWS CloudFormation or custom scripts.
2. State management: Terraform state files can be challenging to manage with multiple team members working on the same infrastructure.

Advantages

Using Terraform for Lambda functions offers several advantages:

1. Version control: Infrastructure code lives alongside application code.
2. Reusability: Modules work across different applications and environments.
3. Streamlined deployments: Changes to Lambda functions deploy more efficiently through Terraform.

Testing Your Lambda Module with Terratest

Terratest is an infrastructure testing library written in Go. It validates Terraform code against deployed resources, which increases quality assurance.

Setting Up Your Test Environment

Before starting, install these tools:

1. Go: Install the latest version from the official website.
2. Terraform: Install the current version.

Create a tests directory inside your Terraform module folder.

Writing the Test Code

Inside the tests directory, create a file named lambda_test.go. Import the necessary packages:

package tests

import (
	"testing"

	"github.com/gruntwork-io/terratest/modules/aws"
	"github.com/gruntwork-io/terratest/modules/random"
	"github.com/gruntwork-io/terratest/modules/terraform"
	"github.com/stretchr/testify/assert"
)

Write a test function that:

1. Creates unique names for AWS resources using random strings.
2. Defines terraform options with input variables and settings.
3. Runs terraform init and terraform apply.
4. Retrieves outputs and AWS resource data.
5. Verifies resources match desired values.
6. Cleans up by running terraform destroy.

Here is a sample test function:

func TestTerraformLambdaModule(t *testing.T) {
	t.Parallel()

	region := "us-west-2"
	functionName := fmt.Sprintf("test_lambda_%s", random.UniqueId())

	terraformOptions := &terraform.Options{
		TerraformDir: "../",
		Vars: map[string]interface{}{
			"function_name": functionName,
			"handler":       "index.handler",
			"runtime":       "nodejs20.x",
			"region":        region,
		},
		EnvVars: map[string]string{
			"AWS_DEFAULT_REGION": region,
		},
	}

	defer terraform.Destroy(t, terraformOptions)
	terraform.InitAndApply(t, terraformOptions)

	lambdaARN := aws.GetLambdaFunctionARN(t, region, functionName)
	assert.NotNil(t, lambdaARN)

	lambdaEnvVars := aws.GetLambdaFunctionEnvironmentVariables(t, region, functionName)
	assert.Equal(t, "some_value", lambdaEnvVars["SOME_ENVIRONMENT_VARIABLE"])
}

Running Your Tests

To execute tests, open a terminal and navigate to the tests directory:

go test -v -timeout 30m

Successful output looks like:

PASS
ok      path/to/your/tests   7.160s

Conclusion

This tutorial covered creating, deploying, and testing a Terraform Lambda module. You learned about reusable modules, trade-offs, limitations, and how to expand a module from simple to complex setups.

Automated testing with Terratest improves quality assurance in infrastructure code. These practices lead to more consistent and maintainable infrastructure across projects.

Continue learning from real-world examples and adapting to changing requirements. With practice, you will manage serverless resources efficiently.

If you want to go further with Lambda beyond infrastructure provisioning, see AWS Lambda + Pillow for complex image processing — a practical guide to building image transformation pipelines with Lambda and the Pillow library.

Happy terraforming!