refactor-module

# Define clear input contract
variable "network_config" {
  description = "Network configuration parameters"
  type = object({
    cidr_block         = string
    availability_zones = list(string)
    enable_nat         = bool
  })
 
  validation {
    condition     = can(cidrhost(var.network_config.cidr_block, 0))
    error_message = "CIDR block must be valid IPv4 CIDR."
  }
}
 
# Define output contract
output "vpc_id" {
  description = "ID of the created VPC"
  value       = aws_vpc.main.id
}
 
output "private_subnet_ids" {
  description = "List of private subnet IDs"
  value       = { for k, v in aws_subnet.private : k => v.id }
}

**What to Include in Module:**
- Tightly coupled resources (VPC + subnets)
- Resources with shared lifecycle
- Configuration with clear boundaries
 
**What to Keep Separate:**
- Cross-cutting concerns (monitoring, tagging)
- Resources with different lifecycles
- Provider-specific configurations

# main.tf (monolithic)
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  enable_dns_hostnames = true
 
  tags = {
    Name = "production-vpc"
    Environment = "prod"
  }
}
 
resource "aws_subnet" "public_1" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "us-east-1a"
 
  tags = {
    Name = "public-subnet-1"
    Type = "public"
  }
}
 
resource "aws_subnet" "public_2" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.2.0/24"
  availability_zone = "us-east-1b"
 
  tags = {
    Name = "public-subnet-2"
    Type = "public"
  }
}
 
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id
 
  tags = {
    Name = "production-igw"
  }
}
 
# ... more repetitive subnet and routing resources

# modules/vpc/main.tf
locals {
  subnet_count = length(var.availability_zones)
}
 
resource "aws_vpc" "main" {
  cidr_block           = var.cidr_block
  enable_dns_hostnames = var.enable_dns_hostnames
  enable_dns_support   = var.enable_dns_support
 
  tags = merge(
    var.tags,
    {
      Name = var.name
    }
  )
}
 
resource "aws_subnet" "public" {
  for_each = var.create_public_subnets ? toset(var.availability_zones) : []
 
  vpc_id                  = aws_vpc.main.id
  cidr_block              = cidrsubnet(var.cidr_block, 8, index(var.availability_zones, each.value))
  availability_zone       = each.value
  map_public_ip_on_launch = true
 
  tags = merge(
    var.tags,
    {
      Name = "${var.name}-public-${each.value}"
      Type = "public"
    }
  )
}
 
resource "aws_internet_gateway" "main" {
  count  = var.create_public_subnets ? 1 : 0
  vpc_id = aws_vpc.main.id
 
  tags = merge(
    var.tags,
    {
      Name = "${var.name}-igw"
    }
  )
}
 
# modules/vpc/variables.tf
variable "name" {
  description = "Name prefix for all resources"
  type        = string
}
 
variable "cidr_block" {
  description = "CIDR block for the VPC"
  type        = string
 
  validation {
    condition     = can(cidrhost(var.cidr_block, 0))
    error_message = "Must be a valid IPv4 CIDR block."
  }
}
 
variable "availability_zones" {
  description = "List of availability zones"
  type        = list(string)
}
 
variable "create_public_subnets" {
  description = "Whether to create public subnets"
  type        = bool
  default     = true
}
 
variable "enable_dns_hostnames" {
  description = "Enable DNS hostnames in the VPC"
  type        = bool
  default     = true
}
 
variable "enable_dns_support" {
  description = "Enable DNS support in the VPC"
  type        = bool
  default     = true
}
 
variable "tags" {
  description = "Tags to apply to all resources"
  type        = map(string)
  default     = {}
}
 
# modules/vpc/outputs.tf
output "vpc_id" {
  description = "ID of the VPC"
  value       = aws_vpc.main.id
}
 
output "vpc_cidr_block" {
  description = "CIDR block of the VPC"
  value       = aws_vpc.main.cidr_block
}
 
output "public_subnet_ids" {
  description = "Map of availability zones to public subnet IDs"
  value       = { for k, v in aws_subnet.public : k => v.id }
}
 
output "internet_gateway_id" {
  description = "ID of the internet gateway"
  value       = try(aws_internet_gateway.main[0].id, null)
}
 
# Root configuration using module
module "vpc" {
  source = "./modules/vpc"
 
  name               = "production"
  cidr_block         = "10.0.0.0/16"
  availability_zones = ["us-east-1a", "us-east-1b", "us-east-1c"]
 
  tags = {
    Environment = "production"
    ManagedBy   = "Terraform"
  }
}

# Enumerate current resource addresses (the inputs for `moved` / `state mv`)
terraform state list
 
# Inspect resolved attribute values when you need them
terraform show -json | jq '.values.root_module'

# migration.tf
# Use moved blocks for state refactoring (Terraform 1.1+)
 
moved {
  from = aws_vpc.main
  to   = module.vpc.aws_vpc.main
}
 
moved {
  from = aws_subnet.public_1
  to   = module.vpc.aws_subnet.public["us-east-1a"]
}
 
moved {
  from = aws_subnet.public_2
  to   = module.vpc.aws_subnet.public["us-east-1b"]
}
 
moved {
  from = aws_internet_gateway.main
  to   = module.vpc.aws_internet_gateway.main[0]
}

# Generate state migration commands
terraform state mv aws_vpc.main module.vpc.aws_vpc.main
terraform state mv aws_subnet.public_1 'module.vpc.aws_subnet.public["us-east-1a"]'
terraform state mv aws_subnet.public_2 'module.vpc.aws_subnet.public["us-east-1b"]'
terraform state mv aws_internet_gateway.main 'module.vpc.aws_internet_gateway.main[0]'

# VPC Module
 
## Overview
Creates a VPC with configurable public and private subnets across multiple availability zones.
 
## Features
- Multi-AZ subnet deployment
- Optional NAT gateway configuration
- VPC Flow Logs integration
- Customizable CIDR allocation
 
## Usage
 
\`\`\`hcl
module "vpc" {
  source = "./modules/vpc"
 
  name               = "my-vpc"
  cidr_block         = "10.0.0.0/16"
  availability_zones = ["us-east-1a", "us-east-1b"]
 
  create_public_subnets  = true
  create_private_subnets = true
  enable_nat_gateway     = true
 
  tags = {
    Environment = "production"
  }
}
\`\`\`
 
## Requirements
 
| Name | Version |
|------|---------|
| terraform | >= 1.5.0 |
| aws | ~> 5.0 |
 
## Inputs
 
| Name | Description | Type | Default | Required |
|------|-------------|------|---------|----------|
| name | Name prefix for resources | `string` | n/a | yes |
| cidr_block | VPC CIDR block | `string` | n/a | yes |
| availability_zones | List of AZs | `list(string)` | n/a | yes |
 
## Outputs
 
| Name | Description |
|------|-------------|
| vpc_id | VPC identifier |
| public_subnet_ids | Map of public subnet IDs |
| private_subnet_ids | Map of private subnet IDs |
 
## Examples
 
See [examples/](./examples/) directory for complete usage examples.

my-module/
├── main.tf
├── variables.tf
├── outputs.tf
└── tests/
    ├── unit_test.tftest.hcl      # Unit test (plan mode)
    └── integration_test.tftest.hcl  # Integration test (apply mode - creates real resources)

# Base module with defaults
module "vpc_base" {
  source = "./modules/vpc-base"
  # Minimal required inputs
}
 
# Environment-specific wrapper
module "vpc_prod" {
  source = "./modules/vpc-production"
  # Inherits from base, adds prod-specific config
}

# Small, focused modules
module "vpc" {
  source = "./modules/vpc"
}
 
module "security_groups" {
  source = "./modules/security-groups"
  vpc_id = module.vpc.vpc_id
}
 
module "application" {
  source     = "./modules/application"
  vpc_id     = module.vpc.vpc_id
  subnet_ids = module.vpc.private_subnet_ids
  sg_ids     = module.security_groups.app_sg_ids
}

# ❌ Don't create overly generic modules
variable "resources" {
  type = map(map(any))  # Too flexible, hard to validate
}
 
# ✅ Do use specific, typed interfaces
variable "database_config" {
  type = object({
    engine         = string
    instance_class = string
  })
}

# ❌ Don't couple modules through direct references
# module A
output "instance_id" { value = aws_instance.app.id }
 
# module B (in same config)
resource "aws_eip" "app" {
  instance = module.a.instance_id  # Tight coupling
}
 
# ✅ Do pass dependencies through root module
module "compute" {
  source = "./modules/compute"
}
 
resource "aws_eip" "app" {
  instance = module.compute.instance_id
}

# Create plan to verify no changes after migration
terraform plan -out=migration.tfplan
 
# Review carefully
terraform show migration.tfplan
 
# Apply only if plan shows no changes
terraform apply migration.tfplan

# Use semantic versioning for modules
module "vpc" {
  source  = "git::https://github.com/org/terraform-modules.git//vpc?ref=v1.2.0"
  version = "~> 1.2"
}
 
# Pin to specific versions in production
# Use version ranges in development