# Real-time Pricing MechCloud displays cost information directly in the plan output before any infrastructure changes are applied. This enables cost-aware infrastructure decisions during development rather than discovering costs after deployment. ### Overview When generating an execution plan, MechCloud calculates and displays comprehensive cost information for AWS resources that have associated costs. ### Supported Billing Models | Model | How it appears in the plan | Examples | | -------------------- | --------------------------------------------- | ------------------------------------------------------ | | Usage-based (hourly) | Hourly rate + max monthly total (744 hours) | EC2, RDS, Lambda duration, NAT Gateway | | Storage (GB-month) | Rate + total when size is known | EBS, S3, RDS storage, DynamoDB storage | | Consumption-based | Rate only (actual usage unknown at plan time) | Lambda requests, DynamoDB on-demand, data transfer out | #### Usage-Based Charges (Price + Cost) For resources with **predictable usage patterns**, MechCloud shows both price rates and calculated costs: * EC2 instance hours * RDS database hours * EBS volume storage (GB-Mo) * Load balancer hours * NAT Gateway hours Example: An EC2 `t3.nano` instance shows `price: $0.00520/Hrs, monthly: $3.87` **EC2 Spot Pricing**: For all on-demand EC2 instances, MechCloud displays both on-demand and spot pricing in the plan output. This helps users evaluate potential cost savings by using spot instances when suitable for their workloads. Example: `vm1 (action: create, price: $0.00520/Hrs, monthly: $3.87, spot-price: $0.00160/Hrs, spot-monthly: $1.19)` #### Consumption-Based Charges (Price Only) For resources with **variable consumption**, MechCloud shows pricing rates but cannot calculate costs without actual usage data: * Data transfer (GB) * DynamoDB requests (Million-WRU, Million-RRU) * S3 requests * Lambda invocations * API Gateway requests * NAT Gateway data processing (GB) **Example**: DynamoDB write request units pricing shown as `Price (Write request units - price: $0.625/Million-WRU)` ### Cost Change Tracking MechCloud displays cost change percentages for all resource actions, helping you understand the financial impact of infrastructure changes. #### Create Actions When creating new resources, the cost change is **+100%** (from $0 to the new cost): ``` vm1 (action: create, price: $0.00520/Hrs, monthly: $3.87, change: +100%) ``` #### Update Actions When modifying existing resources, the change percentage reflects the actual cost difference. **Example: Downsizing an instance from t3.medium to t3.small** ``` vm1 (action: update, price: $0.0208/Hrs, monthly: $15.19, change: -50%) ``` The -50% change indicates a 50% cost reduction from the previous `t3.medium` configuration. **Example: Increasing DynamoDB write capacity from 25 to 35 WCU** ``` provisioned_table (action: update) => Price (Write capacity units) => Tier 1 (First 25 WCU - price: $0.00/WCU-Hrs, quantity: 25, monthly: $0.00, change: 0%) => Tier 2 (Beyond 25 WCU - price: $0.00065/WCU-Hrs, quantity: 10, monthly: $4.84, change: +100%) ``` The +100% change shows new costs since previously all 25 WCU were in the free tier. #### Delete Actions When deleting resources, the cost change is **-100%** (from current cost to $0): ``` vm1 (action: delete, price: $0.00/Hrs, monthly: $0.00, change: -100%) ``` ### Plan Output Examples #### EC2 Instance (Usage-Based Charges) EC2 instances have predictable usage patterns, so MechCloud calculates and displays actual hourly and monthly costs. **Creating an on-demand EC2 instance:** ```yaml resources: - type: aws_ec2_launch_template name: template1 props: launch_template_name: "template1" launch_template_data: instance_type: "t3.nano" image_id: "ami-0bc691261a82b32bc" - type: aws_ec2_instance name: vm1 props: launch_template: launch_template_id: "ref:template1" version: "1" ``` **Plan output:** ``` template1 (action: create) vm1 (action: create, price: $0.00520/Hrs, monthly: $3.87, spot-price: $0.00160/Hrs, spot-monthly: $1.19, change: +100%) ``` The plan shows: * **On-demand price**: `$0.00520/Hrs` - calculated hourly cost for t3.nano instance * **On-demand monthly**: `$3.87` - estimated monthly cost (hourly × 730 hours) * **Spot price**: `$0.00160/Hrs` - spot instance hourly cost for comparison * **Spot monthly**: `$1.19` - estimated monthly spot cost * **Change**: `+100%` - new resource, going from $0 to $3.87/month **Key Feature**: MechCloud displays spot pricing alongside on-demand pricing for all EC2 instances. This encourages users to evaluate spot instances when suitable for their workloads, potentially saving up to 70-90% on compute costs. **Creating a spot EC2 instance:** ```yaml resources: - type: aws_ec2_launch_template name: template1 props: launch_template_name: "template1" launch_template_data: instance_type: "t3.nano" image_id: "ami-0bc691261a82b32bc" instance_market_options: market_type: "spot" - type: aws_ec2_instance name: spot_vm1 props: launch_template: launch_template_id: "ref:template1" version: "1" ``` **Plan output:** ``` template1 (action: create) spot_vm1 (action: create, spot-price: $0.00160/Hrs, spot-monthly: $1.19, change: +100%) ``` For spot instances, only spot pricing is shown since the instance will use spot capacity. The +100% change indicates a new resource. #### DynamoDB Table (Mixed: Usage-Based + Consumption-Based) DynamoDB provisioned capacity tables demonstrate both pricing types - calculated costs for provisioned capacity (usage-based) and pricing rates for storage (consumption-based). **Creating a DynamoDB table (Standard class, provisioned capacity):** ```yaml resources: - name: provisioned_standard type: aws_dynamodb_table props: table_name: "test-provisioned" billing_mode: "PROVISIONED" provisioned_throughput: read_capacity_units: 30 write_capacity_units: 35 attribute_definitions: - attribute_name: "id" attribute_type: "S" key_schema: - attribute_name: "id" key_type: "HASH" ``` **Plan output:** ``` provisioned_standard (action: create, change: +100%) => Price (Write capacity units) => Tier 1 (First 25 WCU - price: $0.00/WCU-Hrs, quantity: 25, monthly: $0.00, change: 0%) => Tier 2 (Beyond 25 WCU - price: $0.00065/WCU-Hrs, quantity: 10, monthly: $4.84, change: +100%) => Price (Read capacity units) => Tier 1 (First 25 RCU - price: $0.00/RCU-Hrs, quantity: 25, monthly: $0.00, change: 0%) => Tier 2 (Beyond 25 RCU - price: $0.00013/RCU-Hrs, quantity: 5, monthly: $0.48, change: +100%) => Price (Storage (standard)) => Tier 1 (First 25 GB - price: $0.00/GB-Mo) => Tier 2 (Beyond 25 GB - price: $0.25/GB-Mo) ``` The plan shows: * **Usage-based (calculated costs)**: Provisioned read/write capacity units with tiered pricing * First 25 WCU/RCU are free * Additional capacity shows `quantity` and calculated `monthly` cost * Example: 10 WCU beyond free tier = `$4.84/month` * **Consumption-based (pricing only)**: Storage shows pricing rates (`$0.25/GB-Mo`) without calculated costs since actual storage volume is unknown at provisioning time **Creating a DynamoDB table (Infrequent Access class):** ```yaml resources: - name: provisioned_standard_ia type: aws_dynamodb_table props: table_name: "test-provisioned" billing_mode: "PROVISIONED" table_class: "STANDARD_INFREQUENT_ACCESS" provisioned_throughput: read_capacity_units: 30 write_capacity_units: 35 attribute_definitions: - attribute_name: "id" attribute_type: "S" key_schema: - attribute_name: "id" key_type: "HASH" ``` **Plan output:** ``` provisioned_standard_ia (action: create, change: +100%) => Price (Write capacity units (IA) - price: $0.00081/WCU-Hrs, quantity: 35, monthly: $21.09, change: +100%) => Price (Read capacity units (IA) - price: $0.00016/RCU-Hrs, quantity: 30, monthly: $3.57, change: +100%) => Price (Storage (IA) - price: $0.10/GB-Mo) ``` The Infrequent Access class shows: * **Higher capacity costs**: No free tier, all capacity units are charged * 35 WCU = `$21.09/month` (calculated) * 30 RCU = `$3.57/month` (calculated) * **Lower storage costs**: `$0.10/GB-Mo` vs `$0.25/GB-Mo` for Standard class (pricing only) ### Supported Resources MechCloud provides real-time pricing for the following AWS resource types: | Offering | Resource Type | | ----------- | ------------------------------- | | EC2 | Instance (Virtual Machine) | | | Volume (EBS) | | | Elastic IP | | | NAT Gateway | | | VPN Connection | | | Transit Gateway | | ECS | Service (Fargate) | | EKS | Cluster | | ElastiCache | Cache Cluster | | | Replication Group | | ELB | Load Balancer (ALB / NLB / GLB) | | Lambda | Capacity Provider | | Lightsail | Instance | | MSK | Managed Kafka Cluster | | RDS | DB Instance | | | DB Cluster (Aurora) | | DynamoDB | Table | | S3 | Bucket | | Route53 | Hosted Zone | For detailed pricing examples, see [Examples (Resources With Cost)](/cloud-computing/stateless-iac/aws/examples-resources-with-cost.md). ### Regional Pricing Costs vary by AWS region. MechCloud automatically applies region-specific pricing. Example - `t3.medium` pricing: ```yaml # us-east-1 instance_type: "t3.medium" # $0.0416/Hr, $30.37/month # ap-south-1 instance_type: "t3.medium" # $0.0448/Hr, $32.70/month ``` ### Using Pricing Data #### Compare Configurations ```yaml # Option A - Compute optimized instance_type: "c6i.2xlarge" # $0.34/Hr, $248.20/month # Option B - General purpose instance_type: "m6i.2xlarge" # $0.384/Hr, $280.32/month ``` #### Track Environment Costs When generating plans for different Resource Contexts: ``` Development environment (context: app-dev) Monthly cost: $125.43 Production environment (context: app-prod) Monthly cost: $892.15 ``` #### Document Cost Decisions ```yaml resources: - type: aws_ec2_instance name: api-server props: # c6i.xlarge for consistent CPU performance # Cost: +$18.25/month vs t3.xlarge # Justified by API latency requirements instance_type: "c6i.xlarge" ``` ### Example Workflow This example demonstrates how real-time pricing helps optimize infrastructure costs during development. #### Initial Configuration ```yaml resources: - type: aws_ec2_instance name: web-server props: instance_type: "t3.large" - type: aws_rds_db_instance name: postgres-db props: instance_class: "db.t3.medium" allocated_storage: 100 ``` When you generate a plan, MechCloud shows costs for each resource. You can then adjust instance types and storage to optimize costs before deploying. #### Cost Optimization By reviewing the pricing information in the plan: 1. **Resize compute**: Change `t3.large` to `t3.medium` to reduce EC2 costs 2. **Adjust storage**: Reduce RDS storage from 100GB to 50GB if appropriate 3. **Consider spot**: Evaluate spot instances for non-critical workloads Each configuration change generates a new plan showing updated costs, enabling iterative optimization before any resources are created. ### Best Practices **Include cost justification in code comments** - Document why specific instance types or sizes were chosen. **Compare costs during code review** - Review cost deltas alongside configuration changes. **Track cost trends over time** - Save plan outputs to monitor infrastructure cost evolution. **Use Resource Context for cost isolation** - Separate cost tracking by environment (dev, staging, prod). **Monitor actual vs estimated costs** - Compare MechCloud estimates against actual cloud bills to refine understanding. ### Integration with Stateless IaC Real-time pricing works seamlessly with MechCloud's stateless architecture: **Fresh pricing every plan** - No stale data from state files **Accurate cost deltas** - Costs compared against actual current state **Environment isolation** - Resource Context enables per-environment cost tracking ### Next Steps * [Examples (Resources With Cost)](/cloud-computing/stateless-iac/aws/examples-resources-with-cost.md) * [Authoring Desired State](/cloud-computing/stateless-iac/aws/authoring-desired-state.md) --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.mechcloud.io/cloud-computing/stateless-iac/aws/real-time-pricing.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.