#AWS
136 posts
Terraform Basics #1 IaC and Terraform: Where Console Clicking Breaks Down, Installation, and the First apply
Tracing how infrastructure built by clicking through the console falls apart — no reproducibility, no history, no review — and how declaring the desired state as code solves each of those problems. We compare where Terraform sits among CloudFormation, CDK, and Pulumi, then walk through installation and a first full cycle: creating an S3 bucket with init, plan, and apply, and removing it with destroy.
Cutting NAT Gateway Costs: The Data Processing Fee Is the Real Bill
A breakdown of the NAT Gateway bill and the order to cut it: the three overlapping charge layers (hourly, data processing, internet transfer), why downloads get charged too, the cost math of each bypass route from free gateway endpoints through interface endpoints, IPv6, and NAT instances, how to find the traffic culprits, and the cost structure of multi-AZ placement.
DynamoDB vs RDS: Choosing an AWS Database
A working standard for choosing between DynamoDB and RDS: the data-model difference between key-value and relational, how per-request versus per-instance-hour billing splits the bill, DynamoDB's constraint of designing access patterns up front, the trap of GSIs multiplying write costs, a selection order driven by traffic patterns, and the setup that runs both side by side.
RI vs Savings Plans: Choosing an AWS Commitment Discount
A working standard for choosing between Reserved Instances and Savings Plans: the structural difference between matching instance attributes and committing to an hourly spend, the flexibility split behind the identical 72% maximum discount, the services Savings Plans cannot cover (RDS and friends), capacity reservation as a separate problem, and how to size a commitment against the stable floor of your bill.
EFS vs EBS vs S3: Choosing AWS Storage
A working standard for choosing among the three AWS storage services: the access-model difference between block, file, and object storage, unit prices that spread from $0.023 to $0.30 per GB and the provisioned-versus-usage billing split behind them, hidden costs like EFS throughput charges, the common overengineering of using EFS without a sharing requirement, and a selection order driven by access patterns.
SQS vs SNS vs EventBridge: Choosing a Messaging Service
A working standard for choosing among the three AWS messaging services: the model difference between a queue, pub/sub, and an event bus, where retention and retries exist and where they do not, pricing that spreads from $0.40 to $1.00 per million with 64KB-chunk billing, combination patterns like SNS-to-SQS fan-out, and the traps of EventBridge latency and FIFO throughput limits.
ALB vs NLB: Choosing a Load Balancer
A working standard for choosing between ALB and NLB: the layer difference between L7 routing and L4 forwarding, the things only NLB can do (static IPs, source IP preservation, PrivateLink), how bills diverge in LCU math even though the hourly rate is identical, hidden costs like cross-zone load balancing, and the chained NLB-to-ALB setup for when you need both.
Lambda vs Fargate: Choosing Serverless Compute
A working standard for choosing between Lambda and Fargate: the structural difference between per-invocation and per-task billing, the unit-price math that makes Lambda over twice as expensive when running continuously and the utilization threshold that follows, Lambda's hard limits (15 minutes, 10GB, cold starts), the hidden costs where API Gateway and log ingestion outgrow the compute bill, and a selection order driven by workload shape.
ECS vs EKS: Choosing a Container Orchestrator
A working standard for choosing between ECS and EKS: why the real cost is bigger than the free-vs-$73/month control plane difference, the EKS upgrade cycle and the extended-support fee that multiplies by six when neglected, what Auto Mode takes off your plate and what it leaves, the conditions where the Kubernetes ecosystem is genuinely required, and how team size, portability, and hiring shape the decision.
Aurora vs RDS: The Structural Difference and When to Switch
A working standard for choosing between Aurora and standard RDS: what the separated compute/storage architecture buys (15 shared-storage read replicas, fast failover, 256TiB auto-scaling), the three-layer pricing where storage and I/O ride on an instance premium, the 25% threshold that makes I/O-Optimized cheaper, Serverless v2 with scale-to-zero, and the conditions where standard RDS remains the right answer.
S3 Storage Classes Compared: Standard to Glacier Deep Archive
A working standard for choosing S3 storage classes: the full map of storage rates versus retrieval fees and minimum durations, the three traps in Standard-IA (retrieval fees, 30 days, 128KB), the real differences between the three Glacier classes (instant, hours, 12+ hours), why Intelligent-Tiering is the answer when access patterns are unknown, and when lifecycle transition fees eat the savings.
ECS Fargate vs EC2: Spec Combinations and Price Compared
A working standard for choosing ECS compute: the structural difference between per-task billing (Fargate) and per-instance billing (EC2), the vCPU/memory grid Fargate allows (0.25-16 vCPU, up to 120GB), what the premium actually amounts to at equal specs, the point where utilization and bin packing flip the comparison, and the levers that cut the bill — ARM, Spot, and Savings Plans.