Create a VPC

module "vpc" {

source = "terraform-aws-modules/vpc/aws"

name = "taskflow-vpc"

cidr = "10.0.0.0/16"

azs = ["$var.aw{s}_{r}egiona","${var.aws_region}b"]

public_subnets = ["10.0.1.0/24", "10.0.2.0/24"]

enable_dns_hostnames = true

enable_dns_support = true

}

Create an ECS cluster

resource "aws_ecs_cluster" "taskflow_cluster" {

name = "taskflow-cluster"

}

Task definition

resource "aws_ecs_task_definition" "taskflow" {

family = "taskflow"

network_mode = "awsvpc"

requires_compatibilities = ["FARGATE"]

cpu = 256

memory = 512

execution_role_arn = var.ecs_execution_role

container_definitions = jsonencode([{

name = "taskflow"

image = var.docker_image

essential = true

portMappings = [{ containerPort = 8000 }]

logConfiguration = {

logDriver = "awslogs"

options = {

awslogs-group = "/ecs/taskflow"

awslogs-region = var.aws_region

awslogs-stream-prefix = "ecs"

}

}

}])

}

Service

resource "aws_ecs_service" "taskflow_service" {

name = "taskflow-service"

cluster = aws_ecs_cluster.taskflow_cluster.id

task_definition = aws_ecs_task_definition.taskflow.arn

desired_count = 2

launch_type = "FARGATE"

network_configuration {

subnets = module.vpc.public_subnets

assign_public_ip = true

}

load_balancer {

target_group_arn = aws_lb_target_group.taskflow_tg.arn

container_name = "taskflow"

container_port = 8000

}

depends_on = [aws_lb_listener.http]

}

Application Load Balancer

resource "aws_lb" "taskflow_alb" {

name = "taskflow-alb"

internal = false

load_balancer_type = "application"

subnets = module.vpc.public_subnets

}

resource "aws_lb_target_group" "taskflow_tg" {

name = "taskflow-tg"

port = 8000

protocol = "HTTP"

vpc_id = module.vpc.vpc_id

}

resource "aws_lb_listener" "http" {

load_balancer_arn = aws_lb.taskflow_alb.arn

port = 80

protocol = "HTTP"

default_action {

type = "forward"

target_group_arn = aws_lb_target_group.taskflow_tg.arn

}

}

variables.tf

variable "aws_region" {

description = "AWS region"

default = "us-east-1"

}

variable "docker_image" {

description = "TaskFlow container image"

type = string

}

variable "ecs_execution_role" {

description = "IAM role for ECS task execution"

type = string

}

outputs.tf

output "load_balancer_dns" {

description = "Public URL of TaskFlow service"

value = aws_lb.taskflow_alb.dns_name

}

Run these commands:

terraform init

terraform plan -var="docker_image=ghcr.io/your-org/taskflow:latest" -var="ecs_execution_role=arn:aws:iam::123456789012:role/ECSExecutionRole"

terraform apply -auto-approve

Once deployed, Terraform outputs your load balancer DNS, and your API becomes accessible via a public endpoint. Claude can now help you test the deployment using simple prompts like:

“Claude, write a curl test to verify that the TaskFlow/health endpoint returns a 200 response through the new load balancer.”

Claude would respond with a one-line verification command:

curl -i http:///health

Clarification Table: Claude’s Role in Infrastructure Automation

| Stage | Traditional Task | Claude’s Assistance | Outcome |
| --- | --- | --- | --- |
| Definition | Writing Terraform/Ansible templates | Generates validated IaC with comments | Saves setup time |
| Validation | Checking dependencies, syntax | Detects cyclic references, missing vars | Prevents runtime errors |
| Optimization | Improving costs and resource usage | Recommends instance types and scaling policies | Reduces cloud spend |
| Compliance | Reviewing IAM and security groups | Suggests least-privilege roles | Increases security |
| Maintenance | Updating and documenting infra | Summarizes diffs and creates changelogs | Keeps infrastructure auditable |

With Claude as your DevOps partner, infrastructure automation becomes both faster and safer. Instead of memorizing every Terraform resource or YAML syntax rule, you describe your intent and let Claude translate it into structured, validated code. Beyond generation, Claude explains the reasoning behind each resource, helping you learn IaC principles organically.

In the next section, you’ll go a step further—automating cloud environments end-to-end, including variable management, secret injection, and cross-environment synchronization—all with Claude Code acting as a real-time assistant that understands your stack and anticipates your operational needs.