* [PATCH v3 1/3] aws: add dynamic cloud configuration support
2025-09-09 0:56 [PATCH v3 0/3] aws: add dynamic kconfig support Luis Chamberlain
@ 2025-09-09 0:56 ` Luis Chamberlain
2025-09-10 20:53 ` Chuck Lever
2025-09-09 0:56 ` [PATCH v3 2/3] aws: enable GPU AMI support for GPU instances Luis Chamberlain
` (2 subsequent siblings)
3 siblings, 1 reply; 6+ messages in thread
From: Luis Chamberlain @ 2025-09-09 0:56 UTC (permalink / raw)
To: Chuck Lever, Daniel Gomez, kdevops; +Cc: Luis Chamberlain
Move away from static AWS kconfig files to dynamic AWS kconfig support.
We leverage AWS APIs to dynamically to generate Kconfig options for instance
types, regions, and AMIs. This ensures users always have access to current
cloud resources without having kdevops admins manually hand craft updates.
This also makes it less error prone, and lets us scale.
To generate new AWS dynamic kconfig files, one can use:
make cloud-config # takes about ~6 minutes
Regular users are not expected to have to call this. Only kdevops admins are.
This will generaed Kconfig *.generated files, which we git-ignore. If we
want to keep these, and propagate them to kdevops users through a commit,
kdevops admins can then run:
make cloud-update
This will generate kconfig *.static file which we do allow to commit.
So users are expected to reap benefit of these kconfig *.static files.
And kdevops admins are the ones who will routinely (once a month or so)
will run both:
make cloud-config
make cloud-update
The implementation generates configuration files on-demand by querying
AWS EC2 APIs. If the AWS CLI is unavailable or not configured, the system
provides hardcoded defaults through fallback functions:
* generate_default_instance_families_kconfig()
* generate_default_regions_kconfig()
* generate_default_gpu_amis_kconfig()
hese return common instance types like m5, t3 and major regions, ensuring
kdevops remains functional without AWS CLI access.
We completely remove all the old AWS static files in favor for the new world
order of dynamic kconfig for cloud. This commit only removes all the
static stuff, and adds all the dynamic kconfig scripts for AWS. In the
subsequent commits we will add static files from a system that does have a
functional aws cli.
New files:
- scripts/aws-cli: CLI wrapper for AWS operations
- scripts/aws_api.py: AWS API functions with fallback defaults
- docs/cloud-configuration.md: Setup and usage documentation
Changes:
- terraform/aws/kconfigs/: Dynamic Kconfig generation replaces static files
- scripts/generate_cloud_configs.py: Parallelize cloud kconfig
generation support to reduce the time it takes
- scripts/dynamic-cloud-kconfig.Makefile: Build system integration
Prerequisites for full functionality:
- AWS CLI installed (pip install awscli)
- AWS credentials configured (~/.aws/credentials or environment variables)
- IAM permissions: ec2:Describe*, pricing:GetProducts (optional)
Without these prerequisites, kdevops uses built-in fallback functions.
Generated-by: Claude AI
Signed-off-by: Luis Chamberlain <mcgrof@kernel.org>
---
.gitignore | 3 +
docs/cloud-configuration.md | 533 ++++++++
docs/kdevops-terraform.md | 9 +
scripts/aws-cli | 436 +++++++
scripts/aws_api.py | 1161 +++++++++++++++++
scripts/dynamic-cloud-kconfig.Makefile | 88 +-
scripts/generate_cloud_configs.py | 193 ++-
terraform/aws/kconfigs/Kconfig.compute | 93 +-
terraform/aws/kconfigs/Kconfig.location | 690 +---------
.../aws/kconfigs/instance-types/Kconfig.c7a | 28 -
.../aws/kconfigs/instance-types/Kconfig.i4i | 33 -
.../aws/kconfigs/instance-types/Kconfig.im4gn | 25 -
.../kconfigs/instance-types/Kconfig.is4gen | 25 -
.../aws/kconfigs/instance-types/Kconfig.m5 | 48 -
.../aws/kconfigs/instance-types/Kconfig.m7a | 57 -
15 files changed, 2430 insertions(+), 992 deletions(-)
create mode 100644 docs/cloud-configuration.md
create mode 100755 scripts/aws-cli
create mode 100755 scripts/aws_api.py
delete mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c7a
delete mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i4i
delete mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.im4gn
delete mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.is4gen
delete mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5
delete mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m7a
diff --git a/.gitignore b/.gitignore
index 720c94b6..3ad57e22 100644
--- a/.gitignore
+++ b/.gitignore
@@ -117,3 +117,6 @@ terraform/lambdalabs/.terraform_api_key
.cloud.initialized
scripts/__pycache__/
+.aws_cloud_config_generated
+terraform/aws/kconfigs/*.generated
+terraform/aws/kconfigs/instance-types/*.generated
diff --git a/docs/cloud-configuration.md b/docs/cloud-configuration.md
new file mode 100644
index 00000000..e330daef
--- /dev/null
+++ b/docs/cloud-configuration.md
@@ -0,0 +1,533 @@
+# Cloud Configuration Management in kdevops
+
+kdevops supports dynamic cloud provider configuration, allowing administrators to generate up-to-date instance types, locations, and AMI options directly from cloud provider APIs. Since generating these configurations can take several minutes (approximately 6 minutes for AWS), kdevops implements a two-tier system to optimize the user experience.
+
+## Overview
+
+The cloud configuration system dynamically generates configuration options by querying cloud provider APIs. This approach provides:
+
+- **Always up-to-date options** from cloud provider APIs
+- **Automatic discovery** of new instance types and regions
+- **No manual maintenance** of configuration files
+- **Fallback defaults** when cloud CLI tools are unavailable
+
+## Prerequisites for Cloud Providers
+
+Before configuring dynamic cloud options, ensure you have Terraform properly set up
+for your chosen cloud provider. For general Terraform setup and cloud provider
+configuration instructions, see the [Terraform Support documentation](kdevops-terraform.md).
+
+### AWS Prerequisites
+
+The AWS dynamic configuration system uses the official AWS CLI tool and requires proper authentication to access AWS APIs.
+
+#### Requirements
+
+1. **AWS CLI Installation**
+ ```bash
+ # Using pip
+ pip install awscli
+
+ # On Debian/Ubuntu
+ sudo apt-get install awscli
+
+ # On Fedora/RHEL
+ sudo dnf install aws-cli
+
+ # On macOS
+ brew install awscli
+ ```
+
+2. **AWS Credentials Configuration**
+
+ You need valid AWS credentials configured in one of these ways:
+
+ a. **AWS credentials file** (`~/.aws/credentials`):
+ ```ini
+ [default]
+ aws_access_key_id = YOUR_ACCESS_KEY
+ aws_secret_access_key = YOUR_SECRET_KEY
+ ```
+
+ b. **Environment variables**:
+ ```bash
+ export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY
+ export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
+ export AWS_DEFAULT_REGION=us-east-1 # Optional
+ ```
+
+ c. **IAM Instance Role** (when running on EC2):
+ - Automatically uses instance metadata service
+ - No explicit credentials needed
+
+3. **Required AWS Permissions**
+
+ The IAM user or role needs the following read-only permissions:
+ ```json
+ {
+ "Version": "2012-10-17",
+ "Statement": [
+ {
+ "Effect": "Allow",
+ "Action": [
+ "ec2:DescribeRegions",
+ "ec2:DescribeAvailabilityZones",
+ "ec2:DescribeInstanceTypes",
+ "ec2:DescribeImages",
+ "pricing:GetProducts"
+ ],
+ "Resource": "*"
+ },
+ {
+ "Effect": "Allow",
+ "Action": [
+ "sts:GetCallerIdentity"
+ ],
+ "Resource": "*"
+ }
+ ]
+ }
+ ```
+
+#### Verifying AWS Setup
+
+Test your AWS CLI configuration:
+```bash
+# Check AWS CLI is installed
+aws --version
+
+# Verify credentials are configured
+aws sts get-caller-identity
+
+# Test EC2 access
+aws ec2 describe-regions --output table
+```
+
+#### Fallback Behavior
+
+If AWS CLI is not available or credentials are not configured:
+- The system automatically uses fallback functions in `scripts/aws_api.py`:
+ - `generate_default_instance_families_kconfig()` - provides M5, M7a, T3, C5, I4i families
+ - `generate_default_regions_kconfig()` - provides common regions (us-east-1, eu-west-1, etc.)
+ - `generate_default_gpu_amis_kconfig()` - provides standard GPU AMI options
+- kdevops remains fully functional for AWS deployments without AWS CLI
+- Users simply get a limited but functional set of hardcoded options instead of
+ the full list from AWS APIs
+
+### Lambda Labs Prerequisites
+
+Lambda Labs configuration requires an API key:
+
+1. **Obtain API Key**: Sign up at [Lambda Labs](https://lambdalabs.com) and generate an API key
+
+2. **Configure API Key**:
+ ```bash
+ export LAMBDA_API_KEY=your_api_key_here
+ ```
+
+3. **Fallback Behavior**: Without an API key, default GPU instance types are provided
+
+## Configuration Generation Flow
+
+```
+Cloud Provider API → Generated Files → Kconfig System
+ ↑ ↑
+ make cloud-config (automatic)
+```
+
+## Available Targets
+
+### `make cloud-config`
+
+Generates dynamic cloud configurations by querying cloud provider APIs.
+
+**Purpose**: Fetches current instance types, regions, availability zones, and AMI options from cloud providers.
+
+**Usage**:
+```bash
+make cloud-config
+```
+
+**What it does**:
+- Queries AWS EC2 API for all available instance types and their specifications
+- Fetches current regions and availability zones
+- Discovers available AMIs including GPU-optimized images
+- Generates Kconfig files with all discovered options
+- Creates `.generated` files in provider-specific directories
+- Sets a marker file (`.aws_cloud_config_generated`) to enable dynamic config
+
+**Time required**: Approximately 6 minutes for AWS (similar for other providers)
+
+**Generated files**:
+- `terraform/aws/kconfigs/Kconfig.compute.generated`
+- `terraform/aws/kconfigs/Kconfig.location.generated`
+- `terraform/aws/kconfigs/Kconfig.gpu-amis.generated`
+- `terraform/aws/kconfigs/instance-types/Kconfig.*.generated`
+- Similar files for other cloud providers
+
+### `make clean-cloud-config`
+
+Removes all generated cloud configuration files.
+
+**Usage**:
+```bash
+make clean-cloud-config
+```
+
+**What it does**:
+- Removes all `.generated` files
+- Removes cloud initialization marker files
+- Forces regeneration on next `make cloud-config`
+
+## Usage Workflow
+
+### For All Users
+
+The cloud configuration system automatically generates options when needed:
+
+1. **Initial setup** (first time only):
+ ```bash
+ make cloud-config # Generate cloud configurations (~6 minutes for AWS)
+ ```
+
+2. **Regular usage**:
+ ```bash
+ make menuconfig # Cloud options are available
+ make defconfig-aws-large
+ make
+ ```
+
+### Fallback Behavior
+
+If cloud CLI tools are not available or API access fails:
+- Fallback functions in the API scripts provide hardcoded defaults:
+ - AWS: `generate_default_*_kconfig()` functions in `scripts/aws_api.py`
+ - Lambda Labs: Similar fallback functions for GPU instances
+- Common instance types (M5, T3, etc.) and major regions remain available
+- Full deployment functionality continues to work
+- Users can still configure and deploy, just with a smaller set of options
+- No error occurs - the system seamlessly falls back to these functions
+
+## How It Works
+
+### Implementation Architecture
+
+The cloud configuration system consists of several key components:
+
+1. **API Wrapper Scripts** (`scripts/aws-cli`, `scripts/lambda-cli`):
+ - Provide CLI interfaces to cloud provider APIs
+ - Handle authentication and error checking
+ - Format API responses for Kconfig generation
+
+2. **API Libraries** (`scripts/aws_api.py`, `scripts/lambdalabs_api.py`):
+ - Core functions for API interactions
+ - Generate Kconfig syntax from API data
+ - Fallback functions (`generate_default_*_kconfig()`) provide hardcoded
+ defaults when APIs unavailable
+
+3. **Generation Orchestrator** (`scripts/generate_cloud_configs.py`):
+ - Coordinates parallel generation across providers
+ - Provides summary information
+ - Handles errors gracefully
+
+4. **Makefile Integration** (`scripts/dynamic-cloud-kconfig.Makefile`):
+ - Defines make targets
+ - Manages file dependencies
+ - Handles cleanup and updates
+
+### AWS Implementation Details
+
+The AWS implementation wraps the official AWS CLI tool rather than implementing its own API client:
+
+```python
+# scripts/aws_api.py
+def run_aws_command(command: List[str], region: str = None) -> Optional[Any]:
+ cmd = ["aws"] + command + ["--output", "json"]
+ # ... executes via subprocess
+```
+
+Key features:
+- **Parallel Generation**: Uses ThreadPoolExecutor to generate instance family files concurrently
+- **GPU Detection**: Automatically identifies GPU instances and enables GPU AMI options
+- **Categorized Instance Types**: Groups instances by use case (general, compute, memory, etc.)
+- **Pricing Integration**: Queries pricing API when available
+- **Smart Defaults**: Falls back to hardcoded defaults when API unavailable, ensuring kdevops always works
+
+### Dynamic Configuration System
+
+kdevops uses dynamic configuration to provide up-to-date cloud options:
+
+- **Generated files** (`.generated`) are created by `make cloud-config`
+- Files are sourced directly by the Kconfig system
+- If generation fails or APIs are unavailable, fallback defaults are provided automatically
+
+The system is designed to be simple and automatic - run `make cloud-config` once
+to generate configurations, then use them with `make menuconfig`.
+
+### Instance Type Organization
+
+Instance types are organized by family for better navigation:
+
+```
+terraform/aws/kconfigs/instance-types/
+├── Kconfig.m5.static # M5 family instances
+├── Kconfig.m7a.static # M7a family instances
+├── Kconfig.g6e.static # G6E GPU instances
+└── ... # Other families
+```
+
+## Supported Cloud Providers
+
+### AWS
+- **Instance types**: All EC2 instance families and sizes
+- **Regions**: All AWS regions and availability zones
+- **AMIs**: Standard distributions and GPU-optimized Deep Learning AMIs
+- **Time to generate**: ~6 minutes
+
+### Azure
+- **Instance types**: All Azure VM sizes
+- **Regions**: All Azure regions
+- **Images**: Standard and specialized images
+- **Time to generate**: ~5-7 minutes
+
+### Google Cloud (GCE)
+- **Instance types**: All GCE machine types
+- **Regions**: All GCE regions and zones
+- **Images**: Public and custom images
+- **Time to generate**: ~5-7 minutes
+
+### Lambda Labs
+- **Instance types**: GPU-optimized instances
+- **Regions**: Available data centers
+- **Images**: ML-optimized images
+- **Time to generate**: ~1-2 minutes
+
+## Benefits
+
+### For Regular Users
+- **Instant configuration** - No waiting for API queries
+- **No cloud CLI required** - Works without AWS CLI, gcloud, or Azure CLI
+- **Consistent experience** - Same options for all users
+- **Offline capable** - Works without internet access
+
+### For Administrators
+- **Centralized updates** - Update once for all users
+- **Version control** - Track configuration changes over time
+- **Reduced API calls** - Query once, use many times
+- **Flexibility** - Can still generate fresh configs when needed
+
+## Best Practices
+
+1. **Update regularly**: Cloud administrators should regenerate configurations monthly or when significant changes occur
+
+2. **Document updates**: Include cloud CLI version and date in commit messages
+
+3. **Test before committing**: Verify generated configurations work correctly:
+ ```bash
+ make cloud-config
+ make menuconfig # Test that options appear correctly
+ ```
+
+4. **Use defconfigs**: Create defconfigs for common cloud configurations:
+ ```bash
+ make savedefconfig
+ cp defconfig defconfigs/aws-gpu-large
+ ```
+
+5. **Handle errors gracefully**: If cloud-config fails, static files still work
+
+## Troubleshooting
+
+### Configuration not appearing in menuconfig
+
+Check if dynamic config is enabled:
+```bash
+ls -la .aws_cloud_config_generated
+grep USE_DYNAMIC_CONFIG .config
+```
+
+### Generated files missing
+
+Run `make cloud-config` to generate the configuration files.
+
+### Old instance types appearing
+
+Regenerate configurations:
+```bash
+make clean-cloud-config
+make cloud-config
+```
+
+## Troubleshooting
+
+### AWS Issues
+
+#### "AWS CLI not found" Error
+```bash
+# Verify AWS CLI installation
+which aws
+aws --version
+
+# Install if missing (see Prerequisites section)
+```
+
+#### "Credentials not configured" Error
+```bash
+# Check current identity
+aws sts get-caller-identity
+
+# If fails, configure credentials:
+aws configure
+# OR
+export AWS_ACCESS_KEY_ID=your_key
+export AWS_SECRET_ACCESS_KEY=your_secret
+```
+
+#### "Access Denied" Errors
+- Verify your IAM user/role has the required permissions (see Prerequisites)
+- Check if you're in the correct AWS account
+- Ensure your credentials haven't expired
+
+#### Slow Generation Times
+- Normal for AWS (6+ minutes due to API pagination)
+- Generation only needed once, then configs are cached
+- Run generation during off-peak hours
+
+#### Missing Instance Types
+```bash
+# Force regeneration
+make clean-cloud-config
+make cloud-config
+```
+
+### General Issues
+
+#### Generated Files Not Loading
+```bash
+# Verify generated files exist
+ls terraform/aws/kconfigs/*.generated
+
+# If missing, regenerate:
+make cloud-config
+```
+
+#### Changes Not Reflected in Menuconfig
+```bash
+# Clear Kconfig cache
+make mrproper
+make menuconfig
+```
+
+#### Debugging API Calls
+```bash
+# Enable debug output
+export DEBUG=1
+make cloud-config
+
+# Test API directly
+scripts/aws-cli --output json regions list
+scripts/aws-cli --output json instance-types list --family m5
+```
+
+## Best Practices
+
+1. **Regular Updates**: Administrators should regenerate configurations monthly or when new instance types are announced
+
+2. **Commit Messages**: Include generation date and tool versions when committing static files:
+ ```bash
+ git commit -m "cloud: update AWS static configurations
+
+ Generated with AWS CLI 2.15.0 on 2024-01-15
+ - Added new G6e instance family
+ - Updated GPU AMI options
+ - 127 instance families now available"
+ ```
+
+3. **Testing**: Always test generated configurations before committing:
+ ```bash
+ make cloud-config
+
+ make menuconfig # Verify options appear correctly
+ ```
+
+4. **Partial Generation**: For faster testing, generate only specific providers:
+ ```bash
+ make cloud-config-aws # AWS only
+ make cloud-config-lambdalabs # Lambda Labs only
+ ```
+
+5. **CI/CD Integration**: Consider automating configuration updates in CI pipelines
+
+## Advanced Usage
+
+### Custom AWS Profiles
+```bash
+# Use non-default AWS profile
+export AWS_PROFILE=myprofile
+make cloud-config
+```
+
+### Specific Region Generation
+```bash
+# Generate for specific region (affects default selections)
+export AWS_DEFAULT_REGION=eu-west-1
+make cloud-config
+```
+
+### Parallel Generation
+The system automatically uses parallel processing:
+- AWS: Up to 10 concurrent instance family generations
+- Reduces total generation time significantly
+
+## File Reference
+
+### AWS Files
+- `terraform/aws/kconfigs/Kconfig.compute.{generated,static}` - Instance families
+- `terraform/aws/kconfigs/Kconfig.location.{generated,static}` - Regions and zones
+- `terraform/aws/kconfigs/Kconfig.gpu-amis.{generated,static}` - GPU AMI options
+- `terraform/aws/kconfigs/instance-types/Kconfig.*.{generated,static}` - Per-family sizes
+
+### Marker Files
+- `.aws_cloud_config_generated` - Enables dynamic AWS config
+- `.cloud.initialized` - General cloud config marker
+
+### Scripts
+- `scripts/aws-cli` - AWS CLI wrapper with user-friendly commands
+- `scripts/aws_api.py` - AWS API library and Kconfig generation
+- `scripts/generate_cloud_configs.py` - Main orchestrator for all providers
+- `scripts/dynamic-cloud-kconfig.Makefile` - Make targets and integration
+
+## Implementation Details
+
+The cloud configuration system is implemented using:
+
+- **AWS CLI Wrapper**: Uses official AWS CLI via subprocess calls
+- **Parallel Processing**: ThreadPoolExecutor for concurrent API calls
+- **Fallback Defaults**: Pre-defined configurations when API unavailable
+- **Two-tier System**: Generated (dynamic) → Static (committed) files
+- **Kconfig Integration**: Seamless integration with Linux kernel-style configuration
+
+### Key Design Decisions
+
+1. **Why wrap AWS CLI instead of using boto3?**
+ - Reduces dependencies (AWS CLI often already installed)
+ - Leverages AWS's official tool and authentication methods
+ - Simpler credential management (uses standard AWS config)
+
+2. **Why the two-tier system?**
+ - Fast loading for regular users (no API calls needed)
+ - Fresh data when administrators regenerate
+ - Works offline and in restricted environments
+
+3. **Why 6 minutes generation time?**
+ - AWS API pagination limits (100 items per request)
+ - Comprehensive data collection (all regions, all instance types)
+ - Parallel processing already optimized
+
+## See Also
+
+- [AWS Instance Types](https://aws.amazon.com/ec2/instance-types/)
+- [Azure VM Sizes](https://docs.microsoft.com/en-us/azure/virtual-machines/sizes)
+- [GCE Machine Types](https://cloud.google.com/compute/docs/machine-types)
+- [kdevops Terraform Documentation](terraform.md)
+- [AWS CLI Documentation](https://docs.aws.amazon.com/cli/)
diff --git a/docs/kdevops-terraform.md b/docs/kdevops-terraform.md
index 3291444d..983dbad5 100644
--- a/docs/kdevops-terraform.md
+++ b/docs/kdevops-terraform.md
@@ -33,6 +33,15 @@ That should let you start configuring your cloud provider options. You can
use the same main menu to configure specific workflows supported by kdevops,
by defaults no workflows are enabled, and so all you get is the bringup.
+### Dynamic Cloud Configuration
+
+kdevops supports dynamic cloud provider configuration that queries live cloud
+APIs for up-to-date instance types, regions, and AMI options. This feature
+ensures you always have access to the latest cloud resources without manual
+updates. For detailed information about dynamic cloud configuration, including
+setup, prerequisites, and advanced usage, see the
+[Cloud Configuration Management documentation](cloud-configuration.md).
+
## Installing dependencies
To install the dependencies of everything which you just enabled just run:
diff --git a/scripts/aws-cli b/scripts/aws-cli
new file mode 100755
index 00000000..6cacce8b
--- /dev/null
+++ b/scripts/aws-cli
@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""
+AWS CLI tool for kdevops
+
+A structured CLI tool that wraps AWS CLI commands and provides access to
+AWS cloud provider functionality for dynamic configuration generation
+and resource management.
+"""
+
+import argparse
+import json
+import sys
+import os
+from typing import Dict, List, Any, Optional, Tuple
+from pathlib import Path
+
+# Import the AWS API functions
+try:
+ from aws_api import (
+ check_aws_cli,
+ get_instance_types,
+ get_regions,
+ get_availability_zones,
+ get_pricing_info,
+ generate_instance_types_kconfig,
+ generate_regions_kconfig,
+ generate_instance_families_kconfig,
+ generate_gpu_amis_kconfig,
+ )
+except ImportError:
+ # Try to import from scripts directory if not in path
+ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+ from aws_api import (
+ check_aws_cli,
+ get_instance_types,
+ get_regions,
+ get_availability_zones,
+ get_pricing_info,
+ generate_instance_types_kconfig,
+ generate_regions_kconfig,
+ generate_instance_families_kconfig,
+ generate_gpu_amis_kconfig,
+ )
+
+
+class AWSCLI:
+ """AWS CLI interface for kdevops"""
+
+ def __init__(self, output_format: str = "json"):
+ """
+ Initialize the CLI with specified output format
+
+ Args:
+ output_format: 'json' or 'text' for output formatting
+ """
+ self.output_format = output_format
+ self.aws_available = check_aws_cli()
+
+ def output(self, data: Any, headers: Optional[List[str]] = None):
+ """
+ Output data in the specified format
+
+ Args:
+ data: Data to output (dict, list, or primitive)
+ headers: Column headers for text format (optional)
+ """
+ if self.output_format == "json":
+ print(json.dumps(data, indent=2))
+ else:
+ # Human-readable text format
+ if isinstance(data, list):
+ if data and isinstance(data[0], dict):
+ # Table format for list of dicts
+ if not headers:
+ headers = list(data[0].keys()) if data else []
+
+ if headers:
+ # Calculate column widths
+ widths = {h: len(h) for h in headers}
+ for item in data:
+ for h in headers:
+ val = str(item.get(h, ""))
+ widths[h] = max(widths[h], len(val))
+
+ # Print header
+ header_line = " | ".join(h.ljust(widths[h]) for h in headers)
+ print(header_line)
+ print("-" * len(header_line))
+
+ # Print rows
+ for item in data:
+ row = " | ".join(
+ str(item.get(h, "")).ljust(widths[h]) for h in headers
+ )
+ print(row)
+ else:
+ # Simple list
+ for item in data:
+ print(item)
+ elif isinstance(data, dict):
+ # Key-value format
+ max_key_len = max(len(k) for k in data.keys()) if data else 0
+ for key, value in data.items():
+ print(f"{key.ljust(max_key_len)} : {value}")
+ else:
+ # Simple value
+ print(data)
+
+ def list_instance_types(
+ self,
+ family: Optional[str] = None,
+ region: Optional[str] = None,
+ max_results: int = 100,
+ ) -> List[Dict[str, Any]]:
+ """
+ List instance types
+
+ Args:
+ family: Filter by instance family (e.g., 'm5', 't3')
+ region: AWS region to query
+ max_results: Maximum number of results to return
+
+ Returns:
+ List of instance type information
+ """
+ if not self.aws_available:
+ return [
+ {
+ "error": "AWS CLI not found. Please install AWS CLI and configure credentials."
+ }
+ ]
+
+ instances = get_instance_types(
+ family=family, region=region, max_results=max_results
+ )
+
+ # Format the results
+ result = []
+ for instance in instances:
+ item = {
+ "name": instance.get("InstanceType", ""),
+ "vcpu": instance.get("VCpuInfo", {}).get("DefaultVCpus", 0),
+ "memory_gb": instance.get("MemoryInfo", {}).get("SizeInMiB", 0) / 1024,
+ "instance_storage": instance.get("InstanceStorageSupported", False),
+ "network_performance": instance.get("NetworkInfo", {}).get(
+ "NetworkPerformance", ""
+ ),
+ "architecture": ", ".join(
+ instance.get("ProcessorInfo", {}).get("SupportedArchitectures", [])
+ ),
+ }
+ result.append(item)
+
+ # Sort by name
+ result.sort(key=lambda x: x["name"])
+
+ return result
+
+ def list_regions(self, include_zones: bool = False) -> List[Dict[str, Any]]:
+ """
+ List regions
+
+ Args:
+ include_zones: Include availability zones for each region
+
+ Returns:
+ List of region information
+ """
+ if not self.aws_available:
+ return [
+ {
+ "error": "AWS CLI not found. Please install AWS CLI and configure credentials."
+ }
+ ]
+
+ regions = get_regions()
+
+ result = []
+ for region in regions:
+ item = {
+ "name": region.get("RegionName", ""),
+ "endpoint": region.get("Endpoint", ""),
+ "opt_in_status": region.get("OptInStatus", ""),
+ }
+
+ if include_zones:
+ # Get availability zones for this region
+ zones = get_availability_zones(region["RegionName"])
+ item["zones"] = len(zones)
+ item["zone_names"] = ", ".join([z["ZoneName"] for z in zones])
+
+ result.append(item)
+
+ return result
+
+ def get_cheapest_instance(
+ self,
+ region: Optional[str] = None,
+ family: Optional[str] = None,
+ min_vcpus: int = 2,
+ ) -> Dict[str, Any]:
+ """
+ Get the cheapest instance meeting criteria
+
+ Args:
+ region: AWS region
+ family: Instance family filter
+ min_vcpus: Minimum number of vCPUs required
+
+ Returns:
+ Dictionary with instance information
+ """
+ if not self.aws_available:
+ return {"error": "AWS CLI not available"}
+
+ instances = get_instance_types(family=family, region=region)
+
+ # Filter by minimum vCPUs
+ eligible = []
+ for instance in instances:
+ vcpus = instance.get("VCpuInfo", {}).get("DefaultVCpus", 0)
+ if vcpus >= min_vcpus:
+ eligible.append(instance)
+
+ if not eligible:
+ return {"error": "No instances found matching criteria"}
+
+ # Get pricing for eligible instances
+ pricing = get_pricing_info(region=region or "us-east-1")
+
+ # Find cheapest
+ cheapest = None
+ cheapest_price = float("inf")
+
+ for instance in eligible:
+ instance_type = instance.get("InstanceType")
+ price = pricing.get(instance_type, {}).get("on_demand", float("inf"))
+ if price < cheapest_price:
+ cheapest_price = price
+ cheapest = instance
+
+ if cheapest:
+ return {
+ "instance_type": cheapest.get("InstanceType"),
+ "vcpus": cheapest.get("VCpuInfo", {}).get("DefaultVCpus", 0),
+ "memory_gb": cheapest.get("MemoryInfo", {}).get("SizeInMiB", 0) / 1024,
+ "price_per_hour": f"${cheapest_price:.3f}",
+ }
+
+ return {"error": "Could not determine cheapest instance"}
+
+ def generate_kconfig(self) -> bool:
+ """
+ Generate Kconfig files for AWS
+
+ Returns:
+ True on success, False on failure
+ """
+ if not self.aws_available:
+ print("AWS CLI not available, cannot generate Kconfig", file=sys.stderr)
+ return False
+
+ output_dir = Path("terraform/aws/kconfigs")
+
+ # Create directory if it doesn't exist
+ output_dir.mkdir(parents=True, exist_ok=True)
+
+ try:
+ from concurrent.futures import ThreadPoolExecutor, as_completed
+
+ # Generate files in parallel
+ instance_types_dir = output_dir / "instance-types"
+ instance_types_dir.mkdir(exist_ok=True)
+
+ def generate_family_file(family):
+ """Generate Kconfig for a single family."""
+ types_kconfig = generate_instance_types_kconfig(family)
+ if types_kconfig:
+ types_file = instance_types_dir / f"Kconfig.{family}.generated"
+ types_file.write_text(types_kconfig)
+ return f"Generated {types_file}"
+ return None
+
+ with ThreadPoolExecutor(max_workers=10) as executor:
+ # Submit all generation tasks
+ futures = []
+
+ # Generate instance families Kconfig
+ futures.append(executor.submit(generate_instance_families_kconfig))
+
+ # Generate regions Kconfig
+ futures.append(executor.submit(generate_regions_kconfig))
+
+ # Generate GPU AMIs Kconfig
+ futures.append(executor.submit(generate_gpu_amis_kconfig))
+
+ # Generate instance types for each family
+ # Get all families dynamically from AWS
+ from aws_api import get_generated_instance_families
+
+ families = get_generated_instance_families()
+
+ family_futures = []
+ for family in sorted(families):
+ family_futures.append(executor.submit(generate_family_file, family))
+
+ # Process main config results
+ families_kconfig = futures[0].result()
+ regions_kconfig = futures[1].result()
+ gpu_amis_kconfig = futures[2].result()
+
+ # Write main configs
+ families_file = output_dir / "Kconfig.compute.generated"
+ families_file.write_text(families_kconfig)
+ print(f"Generated {families_file}")
+
+ regions_file = output_dir / "Kconfig.location.generated"
+ regions_file.write_text(regions_kconfig)
+ print(f"Generated {regions_file}")
+
+ gpu_amis_file = output_dir / "Kconfig.gpu-amis.generated"
+ gpu_amis_file.write_text(gpu_amis_kconfig)
+ print(f"Generated {gpu_amis_file}")
+
+ # Process family results
+ for future in family_futures:
+ result = future.result()
+ if result:
+ print(result)
+
+ return True
+
+ except Exception as e:
+ print(f"Error generating Kconfig: {e}", file=sys.stderr)
+ return False
+
+
+def main():
+ """Main entry point"""
+ parser = argparse.ArgumentParser(
+ description="AWS CLI tool for kdevops",
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ )
+
+ parser.add_argument(
+ "--output",
+ choices=["json", "text"],
+ default="json",
+ help="Output format (default: json)",
+ )
+
+ subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+ # Generate Kconfig command
+ kconfig_parser = subparsers.add_parser(
+ "generate-kconfig", help="Generate Kconfig files for AWS"
+ )
+
+ # Instance types command
+ instances_parser = subparsers.add_parser(
+ "instance-types", help="Manage instance types"
+ )
+ instances_subparsers = instances_parser.add_subparsers(
+ dest="subcommand", help="Instance type operations"
+ )
+
+ # Instance types list
+ list_instances = instances_subparsers.add_parser("list", help="List instance types")
+ list_instances.add_argument("--family", help="Filter by instance family")
+ list_instances.add_argument("--region", help="AWS region")
+ list_instances.add_argument(
+ "--max-results", type=int, default=100, help="Maximum results (default: 100)"
+ )
+
+ # Regions command
+ regions_parser = subparsers.add_parser("regions", help="Manage regions")
+ regions_subparsers = regions_parser.add_subparsers(
+ dest="subcommand", help="Region operations"
+ )
+
+ # Regions list
+ list_regions = regions_subparsers.add_parser("list", help="List regions")
+ list_regions.add_argument(
+ "--include-zones",
+ action="store_true",
+ help="Include availability zones",
+ )
+
+ # Cheapest instance command
+ cheapest_parser = subparsers.add_parser(
+ "cheapest", help="Find cheapest instance meeting criteria"
+ )
+ cheapest_parser.add_argument("--region", help="AWS region")
+ cheapest_parser.add_argument("--family", help="Instance family")
+ cheapest_parser.add_argument(
+ "--min-vcpus", type=int, default=2, help="Minimum vCPUs (default: 2)"
+ )
+
+ args = parser.parse_args()
+
+ cli = AWSCLI(output_format=args.output)
+
+ if args.command == "generate-kconfig":
+ success = cli.generate_kconfig()
+ sys.exit(0 if success else 1)
+
+ elif args.command == "instance-types":
+ if args.subcommand == "list":
+ instances = cli.list_instance_types(
+ family=args.family,
+ region=args.region,
+ max_results=args.max_results,
+ )
+ cli.output(instances)
+
+ elif args.command == "regions":
+ if args.subcommand == "list":
+ regions = cli.list_regions(include_zones=args.include_zones)
+ cli.output(regions)
+
+ elif args.command == "cheapest":
+ result = cli.get_cheapest_instance(
+ region=args.region,
+ family=args.family,
+ min_vcpus=args.min_vcpus,
+ )
+ cli.output(result)
+
+ else:
+ parser.print_help()
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/aws_api.py b/scripts/aws_api.py
new file mode 100755
index 00000000..a9180b31
--- /dev/null
+++ b/scripts/aws_api.py
@@ -0,0 +1,1161 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""
+AWS API library for kdevops.
+
+Provides AWS CLI wrapper functions for dynamic configuration generation.
+Used by aws-cli and other kdevops components.
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+from typing import Dict, List, Optional, Any
+
+
+def check_aws_cli() -> bool:
+ """Check if AWS CLI is installed and configured."""
+ try:
+ # Check if AWS CLI is installed
+ result = subprocess.run(
+ ["aws", "--version"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+ if result.returncode != 0:
+ return False
+
+ # Check if credentials are configured
+ result = subprocess.run(
+ ["aws", "sts", "get-caller-identity"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+ return result.returncode == 0
+ except FileNotFoundError:
+ return False
+
+
+def get_default_region() -> str:
+ """Get the default AWS region from configuration or environment."""
+ # Try to get from environment
+ region = os.environ.get("AWS_DEFAULT_REGION")
+ if region:
+ return region
+
+ # Try to get from AWS config
+ try:
+ result = subprocess.run(
+ ["aws", "configure", "get", "region"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+ if result.returncode == 0 and result.stdout.strip():
+ return result.stdout.strip()
+ except (subprocess.SubprocessError, FileNotFoundError):
+ pass
+
+ # Default to us-east-1
+ return "us-east-1"
+
+
+def run_aws_command(command: List[str], region: Optional[str] = None) -> Optional[Dict]:
+ """
+ Run an AWS CLI command and return the JSON output.
+
+ Args:
+ command: AWS CLI command as a list
+ region: Optional AWS region
+
+ Returns:
+ Parsed JSON output or None on error
+ """
+ cmd = ["aws"] + command + ["--output", "json"]
+
+ # Always specify a region (use default if not provided)
+ if not region:
+ region = get_default_region()
+ cmd.extend(["--region", region])
+
+ try:
+ result = subprocess.run(
+ cmd,
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+ if result.returncode == 0:
+ return json.loads(result.stdout) if result.stdout else {}
+ else:
+ print(f"AWS command failed: {result.stderr}", file=sys.stderr)
+ return None
+ except (subprocess.SubprocessError, json.JSONDecodeError) as e:
+ print(f"Error running AWS command: {e}", file=sys.stderr)
+ return None
+
+
+def get_regions() -> List[Dict[str, Any]]:
+ """Get available AWS regions."""
+ response = run_aws_command(["ec2", "describe-regions"])
+ if response and "Regions" in response:
+ return response["Regions"]
+ return []
+
+
+def get_availability_zones(region: str) -> List[Dict[str, Any]]:
+ """Get availability zones for a specific region."""
+ response = run_aws_command(
+ ["ec2", "describe-availability-zones"],
+ region=region,
+ )
+ if response and "AvailabilityZones" in response:
+ return response["AvailabilityZones"]
+ return []
+
+
+def get_instance_types(
+ family: Optional[str] = None,
+ region: Optional[str] = None,
+ max_results: int = 100,
+ fetch_all: bool = True,
+) -> List[Dict[str, Any]]:
+ """
+ Get available instance types.
+
+ Args:
+ family: Instance family filter (e.g., 'm5', 't3')
+ region: AWS region
+ max_results: Maximum number of results per API call (max 100)
+ fetch_all: If True, fetch all pages using NextToken pagination
+
+ Returns:
+ List of instance type information
+ """
+ all_instances = []
+ next_token = None
+ page_count = 0
+
+ # Ensure max_results doesn't exceed AWS limit
+ max_results = min(max_results, 100)
+
+ while True:
+ cmd = ["ec2", "describe-instance-types"]
+
+ filters = []
+ if family:
+ # Filter by instance type pattern
+ filters.append(f"Name=instance-type,Values={family}*")
+
+ if filters:
+ cmd.append("--filters")
+ cmd.extend(filters)
+
+ cmd.extend(["--max-results", str(max_results)])
+
+ if next_token:
+ cmd.extend(["--next-token", next_token])
+
+ response = run_aws_command(cmd, region=region)
+ if response and "InstanceTypes" in response:
+ batch_size = len(response["InstanceTypes"])
+ all_instances.extend(response["InstanceTypes"])
+ page_count += 1
+
+ if fetch_all and not family:
+ # Only show progress for full fetches (not family-specific)
+ print(
+ f" Fetched page {page_count}: {batch_size} instance types (total: {len(all_instances)})",
+ file=sys.stderr,
+ )
+
+ # Check if there are more results
+ if fetch_all and "NextToken" in response:
+ next_token = response["NextToken"]
+ else:
+ break
+ else:
+ break
+
+ if fetch_all and page_count > 1:
+ filter_desc = f" for family '{family}'" if family else ""
+ print(
+ f" Total: {len(all_instances)} instance types fetched{filter_desc}",
+ file=sys.stderr,
+ )
+
+ return all_instances
+
+
+def get_pricing_info(region: str = "us-east-1") -> Dict[str, Dict[str, float]]:
+ """
+ Get pricing information for instance types.
+
+ Note: AWS Pricing API requires us-east-1 region.
+ Returns a simplified pricing structure.
+
+ Args:
+ region: AWS region for pricing
+
+ Returns:
+ Dictionary mapping instance types to pricing info
+ """
+ # For simplicity, we'll use hardcoded common instance prices
+ # In production, you'd query the AWS Pricing API
+ pricing = {
+ # T3 family (burstable)
+ "t3.nano": {"on_demand": 0.0052},
+ "t3.micro": {"on_demand": 0.0104},
+ "t3.small": {"on_demand": 0.0208},
+ "t3.medium": {"on_demand": 0.0416},
+ "t3.large": {"on_demand": 0.0832},
+ "t3.xlarge": {"on_demand": 0.1664},
+ "t3.2xlarge": {"on_demand": 0.3328},
+ # T3a family (AMD)
+ "t3a.nano": {"on_demand": 0.0047},
+ "t3a.micro": {"on_demand": 0.0094},
+ "t3a.small": {"on_demand": 0.0188},
+ "t3a.medium": {"on_demand": 0.0376},
+ "t3a.large": {"on_demand": 0.0752},
+ "t3a.xlarge": {"on_demand": 0.1504},
+ "t3a.2xlarge": {"on_demand": 0.3008},
+ # M5 family (general purpose Intel)
+ "m5.large": {"on_demand": 0.096},
+ "m5.xlarge": {"on_demand": 0.192},
+ "m5.2xlarge": {"on_demand": 0.384},
+ "m5.4xlarge": {"on_demand": 0.768},
+ "m5.8xlarge": {"on_demand": 1.536},
+ "m5.12xlarge": {"on_demand": 2.304},
+ "m5.16xlarge": {"on_demand": 3.072},
+ "m5.24xlarge": {"on_demand": 4.608},
+ # M7a family (general purpose AMD)
+ "m7a.medium": {"on_demand": 0.0464},
+ "m7a.large": {"on_demand": 0.0928},
+ "m7a.xlarge": {"on_demand": 0.1856},
+ "m7a.2xlarge": {"on_demand": 0.3712},
+ "m7a.4xlarge": {"on_demand": 0.7424},
+ "m7a.8xlarge": {"on_demand": 1.4848},
+ "m7a.12xlarge": {"on_demand": 2.2272},
+ "m7a.16xlarge": {"on_demand": 2.9696},
+ "m7a.24xlarge": {"on_demand": 4.4544},
+ "m7a.32xlarge": {"on_demand": 5.9392},
+ "m7a.48xlarge": {"on_demand": 8.9088},
+ # C5 family (compute optimized)
+ "c5.large": {"on_demand": 0.085},
+ "c5.xlarge": {"on_demand": 0.17},
+ "c5.2xlarge": {"on_demand": 0.34},
+ "c5.4xlarge": {"on_demand": 0.68},
+ "c5.9xlarge": {"on_demand": 1.53},
+ "c5.12xlarge": {"on_demand": 2.04},
+ "c5.18xlarge": {"on_demand": 3.06},
+ "c5.24xlarge": {"on_demand": 4.08},
+ # C7a family (compute optimized AMD)
+ "c7a.medium": {"on_demand": 0.0387},
+ "c7a.large": {"on_demand": 0.0774},
+ "c7a.xlarge": {"on_demand": 0.1548},
+ "c7a.2xlarge": {"on_demand": 0.3096},
+ "c7a.4xlarge": {"on_demand": 0.6192},
+ "c7a.8xlarge": {"on_demand": 1.2384},
+ "c7a.12xlarge": {"on_demand": 1.8576},
+ "c7a.16xlarge": {"on_demand": 2.4768},
+ "c7a.24xlarge": {"on_demand": 3.7152},
+ "c7a.32xlarge": {"on_demand": 4.9536},
+ "c7a.48xlarge": {"on_demand": 7.4304},
+ # I4i family (storage optimized)
+ "i4i.large": {"on_demand": 0.117},
+ "i4i.xlarge": {"on_demand": 0.234},
+ "i4i.2xlarge": {"on_demand": 0.468},
+ "i4i.4xlarge": {"on_demand": 0.936},
+ "i4i.8xlarge": {"on_demand": 1.872},
+ "i4i.16xlarge": {"on_demand": 3.744},
+ "i4i.32xlarge": {"on_demand": 7.488},
+ }
+
+ # Adjust pricing based on region (simplified)
+ # Some regions are more expensive than others
+ region_multipliers = {
+ "us-east-1": 1.0,
+ "us-east-2": 1.0,
+ "us-west-1": 1.08,
+ "us-west-2": 1.0,
+ "eu-west-1": 1.1,
+ "eu-central-1": 1.15,
+ "ap-southeast-1": 1.2,
+ "ap-northeast-1": 1.25,
+ }
+
+ multiplier = region_multipliers.get(region, 1.1)
+ if multiplier != 1.0:
+ adjusted_pricing = {}
+ for instance_type, prices in pricing.items():
+ adjusted_pricing[instance_type] = {
+ "on_demand": prices["on_demand"] * multiplier
+ }
+ return adjusted_pricing
+
+ return pricing
+
+
+def sanitize_kconfig_name(name: str) -> str:
+ """Convert a name to a valid Kconfig symbol."""
+ # Replace special characters with underscores
+ name = name.replace("-", "_").replace(".", "_").replace(" ", "_")
+ # Convert to uppercase
+ name = name.upper()
+ # Remove any non-alphanumeric characters (except underscore)
+ name = "".join(c for c in name if c.isalnum() or c == "_")
+ # Ensure it doesn't start with a number
+ if name and name[0].isdigit():
+ name = "_" + name
+ return name
+
+
+# Cache for instance families to avoid redundant API calls
+_cached_families = None
+
+
+def get_generated_instance_families() -> set:
+ """Get the set of instance families that will have generated Kconfig files."""
+ global _cached_families
+
+ # Return cached result if available
+ if _cached_families is not None:
+ return _cached_families
+
+ # Return all families - we'll generate Kconfig files for all of them
+ # This function will be called by the aws-cli tool to determine which files to generate
+ if not check_aws_cli():
+ # Return a minimal set if AWS CLI is not available
+ _cached_families = {"m5", "t3", "c5"}
+ return _cached_families
+
+ # Get all available instance types
+ print(" Discovering available instance families...", file=sys.stderr)
+ instance_types = get_instance_types(fetch_all=True)
+
+ # Extract unique families
+ families = set()
+ for instance_type in instance_types:
+ type_name = instance_type.get("InstanceType", "")
+ # Extract family prefix (e.g., "m5" from "m5.large")
+ if "." in type_name:
+ family = type_name.split(".")[0]
+ families.add(family)
+
+ print(f" Found {len(families)} instance families", file=sys.stderr)
+ _cached_families = families
+ return families
+
+
+def generate_instance_families_kconfig() -> str:
+ """Generate Kconfig content for AWS instance families."""
+ # Check if AWS CLI is available
+ if not check_aws_cli():
+ return generate_default_instance_families_kconfig()
+
+ # Get all available instance types (with pagination)
+ instance_types = get_instance_types(fetch_all=True)
+
+ # Extract unique families
+ families = set()
+ family_info = {}
+ for instance in instance_types:
+ instance_type = instance.get("InstanceType", "")
+ if "." in instance_type:
+ family = instance_type.split(".")[0]
+ families.add(family)
+ if family not in family_info:
+ family_info[family] = {
+ "architectures": set(),
+ "count": 0,
+ }
+ family_info[family]["count"] += 1
+ for arch in instance.get("ProcessorInfo", {}).get(
+ "SupportedArchitectures", []
+ ):
+ family_info[family]["architectures"].add(arch)
+
+ if not families:
+ return generate_default_instance_families_kconfig()
+
+ # Group families by category - use prefix patterns to catch all variants
+ def categorize_family(family_name):
+ """Categorize a family based on its prefix."""
+ if family_name.startswith(("m", "t")):
+ return "general_purpose"
+ elif family_name.startswith("c"):
+ return "compute_optimized"
+ elif family_name.startswith(("r", "x", "z")):
+ return "memory_optimized"
+ elif family_name.startswith(("i", "d", "h")):
+ return "storage_optimized"
+ elif family_name.startswith(("p", "g", "dl", "trn", "inf", "vt", "f")):
+ return "accelerated"
+ elif family_name.startswith(("mac", "hpc")):
+ return "specialized"
+ else:
+ return "other"
+
+ # Organize families by category
+ categorized_families = {
+ "general_purpose": [],
+ "compute_optimized": [],
+ "memory_optimized": [],
+ "storage_optimized": [],
+ "accelerated": [],
+ "specialized": [],
+ "other": [],
+ }
+
+ for family in sorted(families):
+ category = categorize_family(family)
+ categorized_families[category].append(family)
+
+ kconfig = """# AWS instance families (dynamically generated)
+# Generated by aws-cli from live AWS data
+
+choice
+ prompt "AWS instance family"
+ default TERRAFORM_AWS_INSTANCE_TYPE_M5
+ help
+ Select the AWS instance family for your deployment.
+ Different families are optimized for different workloads.
+
+"""
+
+ # Category headers
+ category_headers = {
+ "general_purpose": "# General Purpose - balanced compute, memory, and networking\n",
+ "compute_optimized": "# Compute Optimized - ideal for CPU-intensive applications\n",
+ "memory_optimized": "# Memory Optimized - for memory-intensive applications\n",
+ "storage_optimized": "# Storage Optimized - for high sequential read/write workloads\n",
+ "accelerated": "# Accelerated Computing - GPU and other accelerators\n",
+ "specialized": "# Specialized - for specific use cases\n",
+ "other": "# Other instance families\n",
+ }
+
+ # Add each category of families
+ for category in [
+ "general_purpose",
+ "compute_optimized",
+ "memory_optimized",
+ "storage_optimized",
+ "accelerated",
+ "specialized",
+ "other",
+ ]:
+ if categorized_families[category]:
+ kconfig += category_headers[category]
+ for family in categorized_families[category]:
+ kconfig += generate_family_config(family, family_info.get(family, {}))
+ if category != "other": # Don't add extra newline after the last category
+ kconfig += "\n"
+
+ kconfig += "\nendchoice\n"
+
+ # Add instance type source includes for each family
+ # Only include families that we actually generate files for
+ generated_families = get_generated_instance_families()
+ kconfig += "\n# Include instance-specific configurations\n"
+ for family in sorted(families):
+ # Only add source statement if we generate a file for this family
+ if family in generated_families:
+ safe_name = sanitize_kconfig_name(family)
+ kconfig += f"""if TERRAFORM_AWS_INSTANCE_TYPE_{safe_name}
+source "terraform/aws/kconfigs/instance-types/Kconfig.{family}.generated"
+endif
+
+"""
+
+ # Add the TERRAFORM_AWS_INSTANCE_TYPE configuration that maps to the actual instance type
+ kconfig += """# Final instance type configuration
+config TERRAFORM_AWS_INSTANCE_TYPE
+ string
+ output yaml
+"""
+
+ # Add default for each family that maps to its size variable
+ for family in sorted(families):
+ safe_name = sanitize_kconfig_name(family)
+ kconfig += f"\tdefault TERRAFORM_AWS_{safe_name}_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_{safe_name}\n"
+
+ # Add a final fallback default
+ kconfig += '\tdefault "t3.micro"\n\n'
+
+ return kconfig
+
+
+def generate_family_config(family: str, info: Dict) -> str:
+ """Generate Kconfig entry for an instance family."""
+ safe_name = sanitize_kconfig_name(family)
+
+ # Determine architecture dependencies
+ architectures = info.get("architectures", set())
+ depends_line = ""
+ if architectures:
+ if "x86_64" in architectures and "arm64" not in architectures:
+ depends_line = "\n\tdepends on TARGET_ARCH_X86_64"
+ elif "arm64" in architectures and "x86_64" not in architectures:
+ depends_line = "\n\tdepends on TARGET_ARCH_ARM64"
+
+ # Family descriptions
+ descriptions = {
+ "t3": "Burstable performance instances powered by Intel processors",
+ "t3a": "Burstable performance instances powered by AMD processors",
+ "m5": "General purpose instances powered by Intel Xeon Platinum processors",
+ "m7a": "Latest generation general purpose instances powered by AMD EPYC processors",
+ "c5": "Compute optimized instances powered by Intel Xeon Platinum processors",
+ "c7a": "Latest generation compute optimized instances powered by AMD EPYC processors",
+ "i4i": "Storage optimized instances with NVMe SSD storage",
+ "is4gen": "Storage optimized ARM instances powered by AWS Graviton2",
+ "im4gn": "Storage optimized ARM instances with NVMe storage",
+ "r5": "Memory optimized instances powered by Intel Xeon Platinum processors",
+ "p3": "GPU instances for machine learning and HPC",
+ "g4dn": "GPU instances for graphics-intensive applications",
+ }
+
+ description = descriptions.get(family, f"AWS {family.upper()} instance family")
+ count = info.get("count", 0)
+
+ config = f"""config TERRAFORM_AWS_INSTANCE_TYPE_{safe_name}
+\tbool "{family.upper()}"
+{depends_line}
+\thelp
+\t {description}
+\t Available instance types: {count}
+
+"""
+ return config
+
+
+def generate_default_instance_families_kconfig() -> str:
+ """Generate default Kconfig content when AWS CLI is not available."""
+ return """# AWS instance families (default - AWS CLI not available)
+
+choice
+ prompt "AWS instance family"
+ default TERRAFORM_AWS_INSTANCE_TYPE_M5
+ help
+ Select the AWS instance family for your deployment.
+ Note: AWS CLI is not available, showing default options.
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5
+ bool "M5"
+ depends on TARGET_ARCH_X86_64
+ help
+ General purpose instances powered by Intel Xeon Platinum processors.
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M7A
+ bool "M7a"
+ depends on TARGET_ARCH_X86_64
+ help
+ Latest generation general purpose instances powered by AMD EPYC processors.
+
+config TERRAFORM_AWS_INSTANCE_TYPE_T3
+ bool "T3"
+ depends on TARGET_ARCH_X86_64
+ help
+ Burstable performance instances powered by Intel processors.
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C5
+ bool "C5"
+ depends on TARGET_ARCH_X86_64
+ help
+ Compute optimized instances powered by Intel Xeon Platinum processors.
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I4I
+ bool "I4i"
+ depends on TARGET_ARCH_X86_64
+ help
+ Storage optimized instances with NVMe SSD storage.
+
+endchoice
+
+# Include instance-specific configurations
+if TERRAFORM_AWS_INSTANCE_TYPE_M5
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M7A
+source "terraform/aws/kconfigs/instance-types/Kconfig.m7a"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_T3
+source "terraform/aws/kconfigs/instance-types/Kconfig.t3.generated"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C5
+source "terraform/aws/kconfigs/instance-types/Kconfig.c5.generated"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I4I
+source "terraform/aws/kconfigs/instance-types/Kconfig.i4i"
+endif
+
+# Final instance type configuration
+config TERRAFORM_AWS_INSTANCE_TYPE
+ string
+ output yaml
+ default TERRAFORM_AWS_M5_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5
+ default TERRAFORM_AWS_M7A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M7A
+ default TERRAFORM_AWS_T3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_T3
+ default TERRAFORM_AWS_C5_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C5
+ default TERRAFORM_AWS_I4I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I4I
+ default "t3.micro"
+
+"""
+
+
+def generate_instance_types_kconfig(family: str) -> str:
+ """Generate Kconfig content for specific instance types within a family."""
+ if not check_aws_cli():
+ return ""
+
+ instance_types = get_instance_types(family=family, fetch_all=True)
+ if not instance_types:
+ return ""
+
+ # Filter to only exact family matches (e.g., c5a but not c5ad)
+ filtered_instances = []
+ for instance in instance_types:
+ instance_type = instance.get("InstanceType", "")
+ if "." in instance_type:
+ inst_family = instance_type.split(".")[0]
+ if inst_family == family:
+ filtered_instances.append(instance)
+
+ instance_types = filtered_instances
+ if not instance_types:
+ return ""
+
+ pricing = get_pricing_info()
+
+ # Sort by vCPU count and memory
+ instance_types.sort(
+ key=lambda x: (
+ x.get("VCpuInfo", {}).get("DefaultVCpus", 0),
+ x.get("MemoryInfo", {}).get("SizeInMiB", 0),
+ )
+ )
+
+ safe_family = sanitize_kconfig_name(family)
+
+ # Get the first instance type to use as default
+ default_instance_name = f"{safe_family}_LARGE" # Fallback
+ if instance_types:
+ first_instance_type = instance_types[0].get("InstanceType", "")
+ if "." in first_instance_type:
+ first_full_name = first_instance_type.replace(".", "_")
+ default_instance_name = sanitize_kconfig_name(first_full_name)
+
+ kconfig = f"""# AWS {family.upper()} instance sizes (dynamically generated)
+
+choice
+\tprompt "Instance size for {family.upper()} family"
+\tdefault TERRAFORM_AWS_INSTANCE_{default_instance_name}
+\thelp
+\t Select the specific instance size within the {family.upper()} family.
+
+"""
+
+ seen_configs = set()
+ for instance in instance_types:
+ instance_type = instance.get("InstanceType", "")
+ if "." not in instance_type:
+ continue
+
+ # Get the full instance type name to make unique config names
+ full_name = instance_type.replace(".", "_")
+ safe_full_name = sanitize_kconfig_name(full_name)
+
+ # Skip if we've already seen this config name
+ if safe_full_name in seen_configs:
+ continue
+ seen_configs.add(safe_full_name)
+
+ size = instance_type.split(".")[1]
+
+ vcpus = instance.get("VCpuInfo", {}).get("DefaultVCpus", 0)
+ memory_mib = instance.get("MemoryInfo", {}).get("SizeInMiB", 0)
+ memory_gb = memory_mib / 1024
+
+ # Get pricing
+ price = pricing.get(instance_type, {}).get("on_demand", 0.0)
+ price_str = f"${price:.3f}/hour" if price > 0 else "pricing varies"
+
+ # Network performance
+ network = instance.get("NetworkInfo", {}).get("NetworkPerformance", "varies")
+
+ # Storage
+ storage_info = ""
+ if instance.get("InstanceStorageSupported"):
+ storage = instance.get("InstanceStorageInfo", {})
+ total_size = storage.get("TotalSizeInGB", 0)
+ if total_size > 0:
+ storage_info = f"\n\t Instance storage: {total_size} GB"
+
+ kconfig += f"""config TERRAFORM_AWS_INSTANCE_{safe_full_name}
+\tbool "{instance_type}"
+\thelp
+\t vCPUs: {vcpus}
+\t Memory: {memory_gb:.1f} GB
+\t Network: {network}
+\t Price: {price_str}{storage_info}
+
+"""
+
+ kconfig += "endchoice\n"
+
+ # Add the actual instance type string config with full instance names
+ kconfig += f"""
+config TERRAFORM_AWS_{safe_family}_SIZE
+\tstring
+"""
+
+ # Generate default mappings for each seen instance type
+ for instance in instance_types:
+ instance_type = instance.get("InstanceType", "")
+ if "." not in instance_type:
+ continue
+
+ full_name = instance_type.replace(".", "_")
+ safe_full_name = sanitize_kconfig_name(full_name)
+
+ kconfig += (
+ f'\tdefault "{instance_type}" if TERRAFORM_AWS_INSTANCE_{safe_full_name}\n'
+ )
+
+ # Use the first instance type as the final fallback default
+ final_default = f"{family}.large"
+ if instance_types:
+ first_instance_type = instance_types[0].get("InstanceType", "")
+ if first_instance_type:
+ final_default = first_instance_type
+
+ kconfig += f'\tdefault "{final_default}"\n\n'
+
+ return kconfig
+
+
+def generate_regions_kconfig() -> str:
+ """Generate Kconfig content for AWS regions."""
+ if not check_aws_cli():
+ return generate_default_regions_kconfig()
+
+ regions = get_regions()
+ if not regions:
+ return generate_default_regions_kconfig()
+
+ kconfig = """# AWS regions (dynamically generated)
+
+choice
+ prompt "AWS region"
+ default TERRAFORM_AWS_REGION_USEAST1
+ help
+ Select the AWS region for your deployment.
+ Note: Not all instance types are available in all regions.
+
+"""
+
+ # Group regions by geographic area
+ us_regions = []
+ eu_regions = []
+ ap_regions = []
+ other_regions = []
+
+ for region in regions:
+ region_name = region.get("RegionName", "")
+ if region_name.startswith("us-"):
+ us_regions.append(region)
+ elif region_name.startswith("eu-"):
+ eu_regions.append(region)
+ elif region_name.startswith("ap-"):
+ ap_regions.append(region)
+ else:
+ other_regions.append(region)
+
+ # Add US regions
+ if us_regions:
+ kconfig += "# US Regions\n"
+ for region in sorted(us_regions, key=lambda x: x.get("RegionName", "")):
+ kconfig += generate_region_config(region)
+ kconfig += "\n"
+
+ # Add EU regions
+ if eu_regions:
+ kconfig += "# Europe Regions\n"
+ for region in sorted(eu_regions, key=lambda x: x.get("RegionName", "")):
+ kconfig += generate_region_config(region)
+ kconfig += "\n"
+
+ # Add Asia Pacific regions
+ if ap_regions:
+ kconfig += "# Asia Pacific Regions\n"
+ for region in sorted(ap_regions, key=lambda x: x.get("RegionName", "")):
+ kconfig += generate_region_config(region)
+ kconfig += "\n"
+
+ # Add other regions
+ if other_regions:
+ kconfig += "# Other Regions\n"
+ for region in sorted(other_regions, key=lambda x: x.get("RegionName", "")):
+ kconfig += generate_region_config(region)
+
+ kconfig += "\nendchoice\n"
+
+ # Add the actual region string config
+ kconfig += """
+config TERRAFORM_AWS_REGION
+ string
+"""
+
+ for region in regions:
+ region_name = region.get("RegionName", "")
+ safe_name = sanitize_kconfig_name(region_name)
+ kconfig += f'\tdefault "{region_name}" if TERRAFORM_AWS_REGION_{safe_name}\n'
+
+ kconfig += '\tdefault "us-east-1"\n'
+
+ return kconfig
+
+
+def generate_region_config(region: Dict) -> str:
+ """Generate Kconfig entry for a region."""
+ region_name = region.get("RegionName", "")
+ safe_name = sanitize_kconfig_name(region_name)
+ opt_in_status = region.get("OptInStatus", "")
+
+ # Region display names
+ display_names = {
+ "us-east-1": "US East (N. Virginia)",
+ "us-east-2": "US East (Ohio)",
+ "us-west-1": "US West (N. California)",
+ "us-west-2": "US West (Oregon)",
+ "eu-west-1": "Europe (Ireland)",
+ "eu-west-2": "Europe (London)",
+ "eu-west-3": "Europe (Paris)",
+ "eu-central-1": "Europe (Frankfurt)",
+ "eu-north-1": "Europe (Stockholm)",
+ "ap-southeast-1": "Asia Pacific (Singapore)",
+ "ap-southeast-2": "Asia Pacific (Sydney)",
+ "ap-northeast-1": "Asia Pacific (Tokyo)",
+ "ap-northeast-2": "Asia Pacific (Seoul)",
+ "ap-south-1": "Asia Pacific (Mumbai)",
+ "ca-central-1": "Canada (Central)",
+ "sa-east-1": "South America (São Paulo)",
+ }
+
+ display_name = display_names.get(region_name, region_name.replace("-", " ").title())
+
+ help_text = f"\t Region: {display_name}"
+ if opt_in_status and opt_in_status != "opt-in-not-required":
+ help_text += f"\n\t Status: {opt_in_status}"
+
+ config = f"""config TERRAFORM_AWS_REGION_{safe_name}
+\tbool "{display_name}"
+\thelp
+{help_text}
+
+"""
+ return config
+
+
+def get_gpu_amis(region: str = None) -> List[Dict[str, Any]]:
+ """
+ Get available GPU-optimized AMIs including Deep Learning AMIs.
+
+ Args:
+ region: AWS region
+
+ Returns:
+ List of AMI information
+ """
+ # Query for Deep Learning AMIs from AWS
+ cmd = ["ec2", "describe-images"]
+ filters = [
+ "Name=owner-alias,Values=amazon",
+ "Name=name,Values=Deep Learning AMI GPU*",
+ "Name=state,Values=available",
+ "Name=architecture,Values=x86_64",
+ ]
+ cmd.append("--filters")
+ cmd.extend(filters)
+ cmd.extend(["--query", "Images[?contains(Name, '2024') || contains(Name, '2025')]"])
+
+ response = run_aws_command(cmd, region=region)
+
+ if response:
+ # Sort by creation date to get the most recent
+ response.sort(key=lambda x: x.get("CreationDate", ""), reverse=True)
+ return response[:10] # Return top 10 most recent
+ return []
+
+
+def generate_gpu_amis_kconfig() -> str:
+ """Generate Kconfig content for GPU AMIs."""
+ # Check if AWS CLI is available
+ if not check_aws_cli():
+ return generate_default_gpu_amis_kconfig()
+
+ # Get available GPU AMIs
+ amis = get_gpu_amis()
+
+ if not amis:
+ return generate_default_gpu_amis_kconfig()
+
+ kconfig = """# GPU-optimized AMIs (dynamically generated)
+
+# GPU AMI Override - only shown for GPU instances
+config TERRAFORM_AWS_USE_GPU_AMI
+ bool "Use GPU-optimized AMI instead of standard distribution"
+ depends on TERRAFORM_AWS_IS_GPU_INSTANCE
+ output yaml
+ default n
+ help
+ Enable this to use a GPU-optimized AMI with pre-installed NVIDIA drivers,
+ CUDA, and ML frameworks instead of the standard distribution AMI.
+
+ When disabled, the standard distribution AMI will be used and you'll need
+ to install GPU drivers manually.
+
+if TERRAFORM_AWS_USE_GPU_AMI
+
+choice
+ prompt "GPU-optimized AMI selection"
+ default TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+ depends on TERRAFORM_AWS_IS_GPU_INSTANCE
+ help
+ Select which GPU-optimized AMI to use for your GPU instance.
+
+config TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+ bool "AWS Deep Learning AMI (Ubuntu 22.04)"
+ help
+ AWS Deep Learning AMI with NVIDIA drivers, CUDA, cuDNN, and popular ML frameworks.
+ Optimized for machine learning workloads on GPU instances.
+ Includes: TensorFlow, PyTorch, MXNet, and Jupyter.
+
+config TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING_NVIDIA
+ bool "NVIDIA Deep Learning AMI"
+ help
+ NVIDIA optimized Deep Learning AMI with latest GPU drivers.
+ Includes NVIDIA GPU Cloud (NGC) containers and frameworks.
+
+config TERRAFORM_AWS_GPU_AMI_CUSTOM
+ bool "Custom GPU AMI"
+ help
+ Specify a custom AMI ID for GPU instances.
+
+endchoice
+
+if TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+
+config TERRAFORM_AWS_GPU_AMI_NAME
+ string
+ output yaml
+ default "Deep Learning AMI GPU TensorFlow*"
+ help
+ AMI name pattern for AWS Deep Learning AMI.
+
+config TERRAFORM_AWS_GPU_AMI_OWNER
+ string
+ output yaml
+ default "amazon"
+
+endif # TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+
+if TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING_NVIDIA
+
+config TERRAFORM_AWS_GPU_AMI_NAME
+ string
+ output yaml
+ default "NVIDIA Deep Learning AMI*"
+ help
+ AMI name pattern for NVIDIA Deep Learning AMI.
+
+config TERRAFORM_AWS_GPU_AMI_OWNER
+ string
+ output yaml
+ default "amazon"
+
+endif # TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING_NVIDIA
+
+if TERRAFORM_AWS_GPU_AMI_CUSTOM
+
+config TERRAFORM_AWS_GPU_AMI_ID
+ string "Custom GPU AMI ID"
+ output yaml
+ help
+ Specify the AMI ID for your custom GPU image.
+ Example: ami-0123456789abcdef0
+
+endif # TERRAFORM_AWS_GPU_AMI_CUSTOM
+
+endif # TERRAFORM_AWS_USE_GPU_AMI
+
+# GPU instance detection
+config TERRAFORM_AWS_IS_GPU_INSTANCE
+ bool
+ output yaml
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G6E
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G6
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G5
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G5G
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G4DN
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G4AD
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P5
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P5EN
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P4D
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P4DE
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P3
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P3DN
+ default n
+ help
+ Automatically detected based on selected instance type.
+ This indicates whether the selected instance has GPU support.
+
+"""
+
+ return kconfig
+
+
+def generate_default_gpu_amis_kconfig() -> str:
+ """Generate default GPU AMI Kconfig when AWS CLI is not available."""
+ return """# GPU-optimized AMIs (default - AWS CLI not available)
+
+# GPU AMI Override - only shown for GPU instances
+config TERRAFORM_AWS_USE_GPU_AMI
+ bool "Use GPU-optimized AMI instead of standard distribution"
+ depends on TERRAFORM_AWS_IS_GPU_INSTANCE
+ output yaml
+ default n
+ help
+ Enable this to use a GPU-optimized AMI with pre-installed NVIDIA drivers,
+ CUDA, and ML frameworks instead of the standard distribution AMI.
+ Note: AWS CLI is not available, showing default options.
+
+if TERRAFORM_AWS_USE_GPU_AMI
+
+choice
+ prompt "GPU-optimized AMI selection"
+ default TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+ depends on TERRAFORM_AWS_IS_GPU_INSTANCE
+ help
+ Select which GPU-optimized AMI to use for your GPU instance.
+
+config TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+ bool "AWS Deep Learning AMI (Ubuntu 22.04)"
+ help
+ Pre-configured with NVIDIA drivers, CUDA, and ML frameworks.
+
+config TERRAFORM_AWS_GPU_AMI_CUSTOM
+ bool "Custom GPU AMI"
+
+endchoice
+
+if TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+
+config TERRAFORM_AWS_GPU_AMI_NAME
+ string
+ output yaml
+ default "Deep Learning AMI GPU TensorFlow*"
+
+config TERRAFORM_AWS_GPU_AMI_OWNER
+ string
+ output yaml
+ default "amazon"
+
+endif # TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+
+if TERRAFORM_AWS_GPU_AMI_CUSTOM
+
+config TERRAFORM_AWS_GPU_AMI_ID
+ string "Custom GPU AMI ID"
+ output yaml
+ help
+ Specify the AMI ID for your custom GPU image.
+
+endif # TERRAFORM_AWS_GPU_AMI_CUSTOM
+
+endif # TERRAFORM_AWS_USE_GPU_AMI
+
+# GPU instance detection (static)
+config TERRAFORM_AWS_IS_GPU_INSTANCE
+ bool
+ output yaml
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G6E
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G6
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G5
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G5G
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G4DN
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G4AD
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P5
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P5EN
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P4D
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P4DE
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P3
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P3DN
+ default n
+ help
+ Automatically detected based on selected instance type.
+ This indicates whether the selected instance has GPU support.
+
+"""
+
+
+def generate_default_regions_kconfig() -> str:
+ """Generate default Kconfig content when AWS CLI is not available."""
+ return """# AWS regions (default - AWS CLI not available)
+
+choice
+ prompt "AWS region"
+ default TERRAFORM_AWS_REGION_USEAST1
+ help
+ Select the AWS region for your deployment.
+ Note: AWS CLI is not available, showing default options.
+
+# US Regions
+config TERRAFORM_AWS_REGION_USEAST1
+ bool "US East (N. Virginia)"
+
+config TERRAFORM_AWS_REGION_USEAST2
+ bool "US East (Ohio)"
+
+config TERRAFORM_AWS_REGION_USWEST1
+ bool "US West (N. California)"
+
+config TERRAFORM_AWS_REGION_USWEST2
+ bool "US West (Oregon)"
+
+# Europe Regions
+config TERRAFORM_AWS_REGION_EUWEST1
+ bool "Europe (Ireland)"
+
+config TERRAFORM_AWS_REGION_EUCENTRAL1
+ bool "Europe (Frankfurt)"
+
+# Asia Pacific Regions
+config TERRAFORM_AWS_REGION_APSOUTHEAST1
+ bool "Asia Pacific (Singapore)"
+
+config TERRAFORM_AWS_REGION_APNORTHEAST1
+ bool "Asia Pacific (Tokyo)"
+
+endchoice
+
+config TERRAFORM_AWS_REGION
+ string
+ default "us-east-1" if TERRAFORM_AWS_REGION_USEAST1
+ default "us-east-2" if TERRAFORM_AWS_REGION_USEAST2
+ default "us-west-1" if TERRAFORM_AWS_REGION_USWEST1
+ default "us-west-2" if TERRAFORM_AWS_REGION_USWEST2
+ default "eu-west-1" if TERRAFORM_AWS_REGION_EUWEST1
+ default "eu-central-1" if TERRAFORM_AWS_REGION_EUCENTRAL1
+ default "ap-southeast-1" if TERRAFORM_AWS_REGION_APSOUTHEAST1
+ default "ap-northeast-1" if TERRAFORM_AWS_REGION_APNORTHEAST1
+ default "us-east-1"
+
+"""
diff --git a/scripts/dynamic-cloud-kconfig.Makefile b/scripts/dynamic-cloud-kconfig.Makefile
index e15651ab..9c9d718e 100644
--- a/scripts/dynamic-cloud-kconfig.Makefile
+++ b/scripts/dynamic-cloud-kconfig.Makefile
@@ -12,9 +12,24 @@ LAMBDALABS_KCONFIG_IMAGES := $(LAMBDALABS_KCONFIG_DIR)/Kconfig.images.generated
LAMBDALABS_KCONFIGS := $(LAMBDALABS_KCONFIG_COMPUTE) $(LAMBDALABS_KCONFIG_LOCATION) $(LAMBDALABS_KCONFIG_IMAGES)
+# AWS dynamic configuration
+AWS_KCONFIG_DIR := terraform/aws/kconfigs
+AWS_KCONFIG_COMPUTE := $(AWS_KCONFIG_DIR)/Kconfig.compute.generated
+AWS_KCONFIG_LOCATION := $(AWS_KCONFIG_DIR)/Kconfig.location.generated
+AWS_INSTANCE_TYPES_DIR := $(AWS_KCONFIG_DIR)/instance-types
+
+# List of AWS instance type family files that will be generated
+AWS_INSTANCE_TYPE_FAMILIES := m5 m7a t3 t3a c5 c7a i4i is4gen im4gn
+AWS_INSTANCE_TYPE_KCONFIGS := $(foreach family,$(AWS_INSTANCE_TYPE_FAMILIES),$(AWS_INSTANCE_TYPES_DIR)/Kconfig.$(family).generated)
+
+AWS_KCONFIGS := $(AWS_KCONFIG_COMPUTE) $(AWS_KCONFIG_LOCATION) $(AWS_INSTANCE_TYPE_KCONFIGS)
+
# Add Lambda Labs generated files to mrproper clean list
KDEVOPS_MRPROPER += $(LAMBDALABS_KCONFIGS)
+# Add AWS generated files to mrproper clean list
+KDEVOPS_MRPROPER += $(AWS_KCONFIGS)
+
# Touch Lambda Labs generated files so Kconfig can source them
# This ensures the files exist (even if empty) before Kconfig runs
dynamic_lambdalabs_kconfig_touch:
@@ -22,20 +37,48 @@ dynamic_lambdalabs_kconfig_touch:
DYNAMIC_KCONFIG += dynamic_lambdalabs_kconfig_touch
+# Touch AWS generated files so Kconfig can source them
+# This ensures the files exist (even if empty) before Kconfig runs
+dynamic_aws_kconfig_touch:
+ $(Q)mkdir -p $(AWS_INSTANCE_TYPES_DIR)
+ $(Q)touch $(AWS_KCONFIG_COMPUTE) $(AWS_KCONFIG_LOCATION)
+ $(Q)touch $(AWS_KCONFIG_DIR)/Kconfig.gpu-amis.generated
+ $(Q)for family in $(AWS_INSTANCE_TYPE_FAMILIES); do \
+ touch $(AWS_INSTANCE_TYPES_DIR)/Kconfig.$$family.generated; \
+ done
+ # Touch all existing generated files
+ $(Q)for file in $(AWS_INSTANCE_TYPES_DIR)/Kconfig.*.generated; do \
+ if [ -f "$$file" ]; then \
+ touch "$$file"; \
+ fi; \
+ done
+
+DYNAMIC_KCONFIG += dynamic_aws_kconfig_touch
+
# Individual Lambda Labs targets are now handled by generate_cloud_configs.py
cloud-config-lambdalabs:
$(Q)python3 scripts/generate_cloud_configs.py
+# Individual AWS targets are now handled by generate_cloud_configs.py
+cloud-config-aws:
+ $(Q)python3 scripts/generate_cloud_configs.py
+
# Clean Lambda Labs generated files
clean-cloud-config-lambdalabs:
$(Q)rm -f $(LAMBDALABS_KCONFIGS)
-DYNAMIC_CLOUD_KCONFIG += cloud-config-lambdalabs
+# Clean AWS generated files
+clean-cloud-config-aws:
+ $(Q)rm -f $(AWS_KCONFIGS)
+
+DYNAMIC_CLOUD_KCONFIG += cloud-config-lambdalabs cloud-config-aws
cloud-config-help:
@echo "Cloud-specific dynamic kconfig targets:"
@echo "cloud-config - generates all cloud provider dynamic kconfig content"
@echo "cloud-config-lambdalabs - generates Lambda Labs dynamic kconfig content"
+ @echo "cloud-config-aws - generates AWS dynamic kconfig content"
+ @echo "cloud-update - converts generated cloud configs to static (for committing)"
@echo "clean-cloud-config - removes all generated cloud kconfig files"
@echo "cloud-list-all - list all cloud instances for configured provider"
@@ -44,11 +87,50 @@ HELP_TARGETS += cloud-config-help
cloud-config:
$(Q)python3 scripts/generate_cloud_configs.py
-clean-cloud-config: clean-cloud-config-lambdalabs
+clean-cloud-config: clean-cloud-config-lambdalabs clean-cloud-config-aws
+ $(Q)rm -f .cloud.initialized
$(Q)echo "Cleaned all cloud provider dynamic Kconfig files."
cloud-list-all:
$(Q)chmod +x scripts/cloud_list_all.sh
$(Q)scripts/cloud_list_all.sh
-PHONY += cloud-config cloud-config-lambdalabs clean-cloud-config clean-cloud-config-lambdalabs cloud-config-help cloud-list-all
+# Convert dynamically generated cloud configs to static versions for git commits
+# This allows admins to generate configs once and commit them for regular users
+cloud-update:
+ @echo "Converting generated cloud configs to static versions..."
+ # AWS configs
+ $(Q)if [ -f $(AWS_KCONFIG_COMPUTE) ]; then \
+ cp $(AWS_KCONFIG_COMPUTE) $(AWS_KCONFIG_DIR)/Kconfig.compute.static; \
+ sed -i 's/Kconfig\.\([^.]*\)\.generated/Kconfig.\1.static/g' $(AWS_KCONFIG_DIR)/Kconfig.compute.static; \
+ echo " Created $(AWS_KCONFIG_DIR)/Kconfig.compute.static"; \
+ fi
+ $(Q)if [ -f $(AWS_KCONFIG_LOCATION) ]; then \
+ cp $(AWS_KCONFIG_LOCATION) $(AWS_KCONFIG_DIR)/Kconfig.location.static; \
+ sed -i 's/Kconfig\.\([^.]*\)\.generated/Kconfig.\1.static/g' $(AWS_KCONFIG_DIR)/Kconfig.location.static; \
+ echo " Created $(AWS_KCONFIG_DIR)/Kconfig.location.static"; \
+ fi
+ # AWS instance type families
+ $(Q)for file in $(AWS_INSTANCE_TYPES_DIR)/Kconfig.*.generated; do \
+ if [ -f "$$file" ]; then \
+ static_file=$$(echo "$$file" | sed 's/\.generated$$/\.static/'); \
+ cp "$$file" "$$static_file"; \
+ echo " Created $$static_file"; \
+ fi; \
+ done
+ # Lambda Labs configs
+ $(Q)if [ -f $(LAMBDALABS_KCONFIG_COMPUTE) ]; then \
+ cp $(LAMBDALABS_KCONFIG_COMPUTE) $(LAMBDALABS_KCONFIG_DIR)/Kconfig.compute.static; \
+ echo " Created $(LAMBDALABS_KCONFIG_DIR)/Kconfig.compute.static"; \
+ fi
+ $(Q)if [ -f $(LAMBDALABS_KCONFIG_LOCATION) ]; then \
+ cp $(LAMBDALABS_KCONFIG_LOCATION) $(LAMBDALABS_KCONFIG_DIR)/Kconfig.location.static; \
+ echo " Created $(LAMBDALABS_KCONFIG_DIR)/Kconfig.location.static"; \
+ fi
+ $(Q)if [ -f $(LAMBDALABS_KCONFIG_IMAGES) ]; then \
+ cp $(LAMBDALABS_KCONFIG_IMAGES) $(LAMBDALABS_KCONFIG_DIR)/Kconfig.images.static; \
+ echo " Created $(LAMBDALABS_KCONFIG_DIR)/Kconfig.images.static"; \
+ fi
+ @echo "Static cloud configs created. You can now commit these .static files to git."
+
+PHONY += cloud-config cloud-config-lambdalabs cloud-config-aws clean-cloud-config clean-cloud-config-lambdalabs clean-cloud-config-aws cloud-config-help cloud-list-all cloud-update
diff --git a/scripts/generate_cloud_configs.py b/scripts/generate_cloud_configs.py
index b16294dd..b208f170 100755
--- a/scripts/generate_cloud_configs.py
+++ b/scripts/generate_cloud_configs.py
@@ -10,6 +10,9 @@ import os
import sys
import subprocess
import json
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Tuple
def generate_lambdalabs_kconfig() -> bool:
@@ -100,29 +103,189 @@ def get_lambdalabs_summary() -> tuple[bool, str]:
return False, "Lambda Labs: Error querying API - using defaults"
+def generate_aws_kconfig() -> bool:
+ """
+ Generate AWS Kconfig files.
+ Returns True on success, False on failure.
+ """
+ script_dir = os.path.dirname(os.path.abspath(__file__))
+ cli_path = os.path.join(script_dir, "aws-cli")
+
+ # Generate the Kconfig files
+ result = subprocess.run(
+ [cli_path, "generate-kconfig"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+
+ return result.returncode == 0
+
+
+def get_aws_summary() -> tuple[bool, str]:
+ """
+ Get a summary of AWS configurations using aws-cli.
+ Returns (success, summary_string)
+ """
+ script_dir = os.path.dirname(os.path.abspath(__file__))
+ cli_path = os.path.join(script_dir, "aws-cli")
+
+ try:
+ # Check if AWS CLI is available
+ result = subprocess.run(
+ ["aws", "--version"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+
+ if result.returncode != 0:
+ return False, "AWS: AWS CLI not installed - using defaults"
+
+ # Check if credentials are configured
+ result = subprocess.run(
+ ["aws", "sts", "get-caller-identity"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+
+ if result.returncode != 0:
+ return False, "AWS: Credentials not configured - using defaults"
+
+ # Get instance types count
+ result = subprocess.run(
+ [
+ cli_path,
+ "--output",
+ "json",
+ "instance-types",
+ "list",
+ "--max-results",
+ "100",
+ ],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+
+ if result.returncode != 0:
+ return False, "AWS: Error querying API - using defaults"
+
+ instances = json.loads(result.stdout)
+ instance_count = len(instances)
+
+ # Get regions
+ result = subprocess.run(
+ [cli_path, "--output", "json", "regions", "list"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+
+ if result.returncode == 0:
+ regions = json.loads(result.stdout)
+ region_count = len(regions)
+ else:
+ region_count = 0
+
+ # Get price range from a sample of instances
+ prices = []
+ for instance in instances[:20]: # Sample first 20 for speed
+ if "error" not in instance:
+ # Extract price if available (would need pricing API)
+ # For now, we'll use placeholder
+ vcpus = instance.get("vcpu", 0)
+ if vcpus > 0:
+ # Rough estimate: $0.05 per vCPU/hour
+ estimated_price = vcpus * 0.05
+ prices.append(estimated_price)
+
+ # Format summary
+ if prices:
+ min_price = min(prices)
+ max_price = max(prices)
+ price_range = f"~${min_price:.2f}-${max_price:.2f}/hr"
+ else:
+ price_range = "pricing varies by region"
+
+ return (
+ True,
+ f"AWS: {instance_count} instance types available, "
+ f"{region_count} regions, {price_range}",
+ )
+
+ except (subprocess.SubprocessError, json.JSONDecodeError, KeyError):
+ return False, "AWS: Error querying API - using defaults"
+
+
+def process_lambdalabs() -> Tuple[bool, bool, str]:
+ """Process Lambda Labs configuration generation and summary.
+ Returns (kconfig_generated, summary_success, summary_text)
+ """
+ kconfig_generated = generate_lambdalabs_kconfig()
+ success, summary = get_lambdalabs_summary()
+ return kconfig_generated, success, summary
+
+
+def process_aws() -> Tuple[bool, bool, str]:
+ """Process AWS configuration generation and summary.
+ Returns (kconfig_generated, summary_success, summary_text)
+ """
+ kconfig_generated = generate_aws_kconfig()
+ success, summary = get_aws_summary()
+
+ return kconfig_generated, success, summary
+
+
def main():
"""Main function to generate cloud configurations."""
print("Cloud Provider Configuration Summary")
print("=" * 60)
print()
- # Lambda Labs - Generate Kconfig files first
- kconfig_generated = generate_lambdalabs_kconfig()
+ # Run cloud provider operations in parallel
+ results = {}
+ any_success = False
- # Lambda Labs - Get summary
- success, summary = get_lambdalabs_summary()
- if success:
- print(f"✓ {summary}")
- if kconfig_generated:
- print(" Kconfig files generated successfully")
- else:
- print(" Warning: Failed to generate Kconfig files")
- else:
- print(f"⚠ {summary}")
- print()
+ with ThreadPoolExecutor(max_workers=4) as executor:
+ # Submit all tasks
+ futures = {
+ executor.submit(process_lambdalabs): "lambdalabs",
+ executor.submit(process_aws): "aws",
+ }
+
+ # Process results as they complete
+ for future in as_completed(futures):
+ provider = futures[future]
+ try:
+ results[provider] = future.result()
+ except Exception as e:
+ results[provider] = (
+ False,
+ False,
+ f"{provider.upper()}: Error - {str(e)}",
+ )
+
+ # Display results in consistent order
+ for provider in ["lambdalabs", "aws"]:
+ if provider in results:
+ kconfig_gen, success, summary = results[provider]
+ if success and kconfig_gen:
+ any_success = True
+ if success:
+ print(f"✓ {summary}")
+ if kconfig_gen:
+ print(" Kconfig files generated successfully")
+ else:
+ print(" Warning: Failed to generate Kconfig files")
+ else:
+ print(f"⚠ {summary}")
+ print()
- # AWS (placeholder - not implemented)
- print("⚠ AWS: Dynamic configuration not yet implemented")
+ # Create .cloud.initialized if any provider succeeded
+ if any_success:
+ Path(".cloud.initialized").touch()
# Azure (placeholder - not implemented)
print("⚠ Azure: Dynamic configuration not yet implemented")
diff --git a/terraform/aws/kconfigs/Kconfig.compute b/terraform/aws/kconfigs/Kconfig.compute
index 4b9c6efb..07b0e6ea 100644
--- a/terraform/aws/kconfigs/Kconfig.compute
+++ b/terraform/aws/kconfigs/Kconfig.compute
@@ -1,94 +1,19 @@
-choice
- prompt "AWS instance types"
- help
- Instance types comprise varying combinations of hardware
- platform, CPU count, memory size, storage, and networking
- capacity. Select the type that provides an appropriate mix
- of resources for your preferred workflows.
-
- Some instance types are region- and capacity-limited.
-
- See https://aws.amazon.com/ec2/instance-types/ for
- details.
-
-config TERRAFORM_AWS_INSTANCE_TYPE_M5
- bool "M5"
- depends on TARGET_ARCH_X86_64
- help
- This is a general purpose type powered by Intel Xeon®
- Platinum 8175M or 8259CL processors (Skylake or Cascade
- Lake).
-
- See https://aws.amazon.com/ec2/instance-types/m5/ for
- details.
-
-config TERRAFORM_AWS_INSTANCE_TYPE_M7A
- bool "M7a"
- depends on TARGET_ARCH_X86_64
- help
- This is a general purpose type powered by 4th Generation
- AMD EPYC processors.
-
- See https://aws.amazon.com/ec2/instance-types/m7a/ for
- details.
-
-config TERRAFORM_AWS_INSTANCE_TYPE_I4I
- bool "I4i"
- depends on TARGET_ARCH_X86_64
- help
- This is a storage-optimized type powered by 3rd generation
- Intel Xeon Scalable processors (Ice Lake) and use AWS Nitro
- NVMe SSDs.
+# AWS compute configuration
- See https://aws.amazon.com/ec2/instance-types/i4i/ for
- details.
-
-config TERRAFORM_AWS_INSTANCE_TYPE_IS4GEN
- bool "Is4gen"
- depends on TARGET_ARCH_ARM64
- help
- This is a Storage-optimized type powered by AWS Graviton2
- processors.
-
- See https://aws.amazon.com/ec2/instance-types/i4g/ for
- details.
-
-config TERRAFORM_AWS_INSTANCE_TYPE_IM4GN
- bool "Im4gn"
- depends on TARGET_ARCH_ARM64
- help
- This is a storage-optimized type powered by AWS Graviton2
- processors.
-
- See https://aws.amazon.com/ec2/instance-types/i4g/ for
- details.
-
-config TERRAFORM_AWS_INSTANCE_TYPE_C7A
- depends on TARGET_ARCH_X86_64
- bool "c7a"
- help
- This is a compute-optimized type powered by 4th generation
- AMD EPYC processors.
-
- See https://aws.amazon.com/ec2/instance-types/c7a/ for
- details.
-
-endchoice
+# Include dynamically generated instance families
+# Generated by 'make cloud-config' from AWS API
+source "terraform/aws/kconfigs/Kconfig.compute.generated"
-source "terraform/aws/kconfigs/instance-types/Kconfig.m5"
-source "terraform/aws/kconfigs/instance-types/Kconfig.m7a"
-source "terraform/aws/kconfigs/instance-types/Kconfig.i4i"
-source "terraform/aws/kconfigs/instance-types/Kconfig.is4gen"
-source "terraform/aws/kconfigs/instance-types/Kconfig.im4gn"
-source "terraform/aws/kconfigs/instance-types/Kconfig.c7a"
+# Include GPU AMI configuration
+source "terraform/aws/kconfigs/Kconfig.gpu-amis.generated"
choice
prompt "Linux distribution"
default TERRAFORM_AWS_DISTRO_DEBIAN
help
- Select a popular Linux distribution to install on your
- instances, or use the "Custom AMI image" selection to
- choose an image that is off the beaten path.
+ Select a popular Linux distribution to install on your
+ instances, or use the "Custom AMI image" selection to
+ choose an image that is off the beaten path.
config TERRAFORM_AWS_DISTRO_AMAZON
bool "Amazon Linux"
diff --git a/terraform/aws/kconfigs/Kconfig.location b/terraform/aws/kconfigs/Kconfig.location
index e5dacb9d..fbdf7eb1 100644
--- a/terraform/aws/kconfigs/Kconfig.location
+++ b/terraform/aws/kconfigs/Kconfig.location
@@ -1,679 +1,21 @@
-choice
- prompt "AWS region"
- default TERRAFORM_AWS_REGION_US_WEST_2
- help
- Use this option to select the AWS region that hosts your
- compute and storage resources. If you do not explicitly
- specify a region, the US West (Oregon) region is the
- default.
-
- Once selected, you can stick with the default AV zone
- chosen by kdevops, or use:
-
- aws ec2 describe-availability-zones --region <region-name>
-
- to list the Availability Zones that are enabled for your
- AWS account. Enter your selection from this list using the
- TERRAFORM_AWS_AV_ZONE menu.
-
- If you wish to expand on the region list, send a patch after
- reading this list:
-
- https://docs.aws.amazon.com/general/latest/gr/rande.html
-
- Note that if you change region the AMI may change as well even
- for the same distribution. At least that applies to Amazon EC2
- optimized images. Use the AWS console, to set that up it will
- ask you for your credentials and then a region. Before adding
- an entry for ami image be sure you are on the region and then
- query with something like:
-
- aws ec2 describe-images --image-ids ami-0efa651876de2a5ce
-
- For instance, this AMI belongs to us-west-2 only. us-east* have
- other AMIs for the same Amazon 2023 EC2 image. The output from
- here tells me:
-
- "OwnerId": "137112412989"
-
- And that is what value to use for ami-0efa651876de2a5ce
- for the TERRAFORM_AWS_AMI_OWNER. To get the ami-* for your regions
- just go to your EC2 console, that console will be associated with
- a region already. You have to change regions if you want to look
- for AMIs in other regions. There are for example two different
- ami-* values for Amazon Linux 2023 for different regions. However
- they values can be same. For example below are the us-west-2 queries
- for Amazon Linux 2023 for x86_64 and then for ARM64.
-
- aws ec2 describe-images --image-ids ami-0efa651876de2a5ce | grep OwnerId
- "OwnerId": "137112412989",
- aws ec2 describe-images --image-ids ami-0699f753302dd8b00 | grep OwnerId
- "OwnerId": "137112412989",
-
-config TERRAFORM_AWS_REGION_AP_NORTHEAST_1
- bool "ap-northeast-1 - Tokyo"
- help
- This option specifies the Asia-Pacific northeast-1 region.
- The data center is located in Tokyo, Japan.
-
-config TERRAFORM_AWS_REGION_AP_NORTHEAST_2
- bool "ap-northeast-2 - Seoul"
- help
- This option specifies the Asia-Pacific northeast-2 region.
- The data center is located in Seoul, South Korea.
-
-config TERRAFORM_AWS_REGION_AP_NORTHEAST_3
- bool "ap-northeast-3 - Osaka"
- help
- This option specifies the Asia-Pacific northeast-3 region.
- The data center is located in Osaka, Japan.
-
-config TERRAFORM_AWS_REGION_AP_SOUTH_1
- bool "ap-south-1 - Mumbai"
- help
- This option specifies the Asia-Pacific south-1 region.
- The data center is located in Mumbai, India.
-
-config TERRAFORM_AWS_REGION_AP_SOUTHEAST_1
- bool "ap-southeast-1 - Singapore"
- help
- This option specifies the Asia-Pacific southeast-1 region.
- The data center is located in the Republic of Singapore.
-
-config TERRAFORM_AWS_REGION_AP_SOUTHEAST_2
- bool "ap-southeast-1 - Sydney"
- help
- This option specifies the Asia-Pacific southeast-2 region.
- The data center is located in Sydney, Australia.
-
-config TERRAFORM_AWS_REGION_CA_CENTRAL_1
- bool "ca-central-1 - Central"
- help
- This option specifies the Canada central-1 region.
- The data center is located in Montreal, Quebec.
-
-config TERRAFORM_AWS_REGION_EU_CENTRAL_1
- bool "eu-central-1 - Frankfurt"
- help
- This option specifies the European Union central-1 region.
- The data center is located in Frankfurt, Germany.
-
-config TERRAFORM_AWS_REGION_EU_NORTH_1
- bool "eu-north-1 - Stockholm"
- help
- This option specifies the European Union north-1 region.
- The data center is located in Stockholm, Sweden.
-
-config TERRAFORM_AWS_REGION_EU_WEST_1
- bool "eu-west-1 - Ireland"
- help
- This option specifies the European Union west-1 region.
- The data center is located in Dublin, Republic of Ireland.
-
-config TERRAFORM_AWS_REGION_EU_WEST_2
- bool "eu-west-2 - London"
- help
- This option specifies the European Union west-2 region.
- The data center is located in London, United Kingdom.
-
-config TERRAFORM_AWS_REGION_EU_WEST_3
- bool "eu-west-3 - Paris"
- help
- This option specifies the European Union west-3 region.
- The data center is located in Paris, France.
-
-config TERRAFORM_AWS_REGION_SA_EAST_1
- bool "sa-east-1 - Sao Paulo"
- help
- This option specifies the South America east-1 region.
- The data center is located in São Paulo, Brazil.
-
-config TERRAFORM_AWS_REGION_US_EAST_1
- bool "us-east-1 - N. Virginia"
- help
- This option specifies the United States east-1 region.
- Multiple data centers are located in the US state of
- Virginia.
-
-config TERRAFORM_AWS_REGION_US_EAST_2
- bool "us-east-2 - Ohio"
- help
- This option specifies the United States east-2 region.
- The data center is located in Columbus, Ohio, US.
-
-config TERRAFORM_AWS_REGION_US_WEST_1
- bool "us-west-1 - North California"
- help
- This option specifies the United States west-1 region.
- The data center is located in San Francisco, California,
- US.
-
-config TERRAFORM_AWS_REGION_US_WEST_2
- bool "us-west-2 - Oregon"
- help
- This option specifies the United States west-2 region.
- Multiple data centers are located in the US state of
- Oregon.
-
-endchoice
-
-config TERRAFORM_AWS_REGION
- string
- output yaml
- default "ap-northeast-1" if TERRAFORM_AWS_REGION_AP_NORTHEAST_1
- default "ap-northeast-2" if TERRAFORM_AWS_REGION_AP_NORTHEAST_2
- default "ap-northeast-3" if TERRAFORM_AWS_REGION_AP_NORTHEAST_3
- default "ap-south-1" if TERRAFORM_AWS_REGION_AP_SOUTH_1
- default "ap-southeast-1" if TERRAFORM_AWS_REGION_AP_SOUTHEAST_1
- default "ap-southeast-2" if TERRAFORM_AWS_REGION_AP_SOUTHEAST_2
- default "ca-central-1" if TERRAFORM_AWS_REGION_CA_CENTRAL_1
- default "eu-central-1" if TERRAFORM_AWS_REGION_EU_CENTRAL_1
- default "eu-north-1" if TERRAFORM_AWS_REGION_EU_NORTH_1
- default "eu-west-1" if TERRAFORM_AWS_REGION_EU_WEST_1
- default "eu-west-2" if TERRAFORM_AWS_REGION_EU_WEST_2
- default "eu-west-3" if TERRAFORM_AWS_REGION_EU_WEST_3
- default "sa-east-1" if TERRAFORM_AWS_REGION_SA_EAST_1
- default "us-east-1" if TERRAFORM_AWS_REGION_US_EAST_1
- default "us-east-2" if TERRAFORM_AWS_REGION_US_EAST_2
- default "us-west-1" if TERRAFORM_AWS_REGION_US_WEST_1
- default "us-west-2" if TERRAFORM_AWS_REGION_US_WEST_2
-
-if TERRAFORM_AWS_REGION_AP_NORTHEAST_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_1A
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_1A
- bool "ap-northeast-1a"
- help
- This option selects the ap-northeast-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_1C
- bool "ap-northeast-1c"
- help
- This option selects the ap-northeast-1c availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_1D
- bool "ap-northeast-1d"
- help
- This option selects the ap-northeast-1d availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_AP_NORTHEAST_1
-
-if TERRAFORM_AWS_REGION_AP_NORTHEAST_2
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2A
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2A
- bool "ap-northeast-2a"
- help
- This option selects the ap-northeast-2a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2B
- bool "ap-northeast-2b"
- help
- This option selects the ap-northeast-2b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2C
- bool "ap-northeast-2c"
- help
- This option selects the ap-northeast-2c availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2D
- bool "ap-northeast-2d"
- help
- This option selects the ap-northeast-2d availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_AP_NORTHEAST_2
-
-if TERRAFORM_AWS_REGION_AP_NORTHEAST_3
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_3A
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_3A
- bool "ap-northeast-3a"
- help
- This option selects the ap-northeast-3a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_3B
- bool "ap-northeast-3b"
- help
- This option selects the ap-northeast-3b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_3C
- bool "ap-northeast-3c"
- help
- This option selects the ap-northeast-3c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_AP_NORTHEAST_3
-
-if TERRAFORM_AWS_REGION_AP_SOUTH_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_AP_SOUTH_1A
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTH_1A
- bool "ap-south-1a"
- help
- This option selects the ap-south-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTH_1B
- bool "ap-south-1b"
- help
- This option selects the ap-south-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTH_1C
- bool "ap-south-1c"
- help
- This option selects the ap-south-1c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_AP_SOUTH_1
-
-if TERRAFORM_AWS_REGION_AP_SOUTHEAST_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_1A
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_1A
- bool "ap-southeast-1a"
- help
- This option selects the ap-southeast-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_1B
- bool "ap-southeast-1b"
- help
- This option selects the ap-southeast-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_1C
- bool "ap-southeast-1c"
- help
- This option selects the ap-southeast-1c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_AP_SOUTHEAST_1
-
-if TERRAFORM_AWS_REGION_AP_SOUTHEAST_2
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_2A
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_2A
- bool "ap-southeast-2a"
- help
- This option selects the ap-southeast-2a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_2B
- bool "ap-southeast-2b"
- help
- This option selects the ap-southeast-2b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_2C
- bool "ap-southeast-2c"
- help
- This option selects the ap-southeast-2c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_AP_SOUTHEAST_2
+# AWS location configuration
-if TERRAFORM_AWS_REGION_CA_CENTRAL_1
+# Include dynamically generated regions
+# Generated by 'make cloud-config' from AWS API
+source "terraform/aws/kconfigs/Kconfig.location.generated"
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_CA_CENTRAL_1A
-
-config TERRAFORM_AWS_AV_ZONE_CA_CENTRAL_1A
- bool "ca-central-1a"
- help
- This option selects the ca-central-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_CA_CENTRAL_1B
- bool "ca-central-1b"
- help
- This option selects the ca-central-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_CA_CENTRAL_1D
- bool "ca-central-1d"
- help
- This option selects the ca-central-1d availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_CA_CENTRAL_1
-
-if TERRAFORM_AWS_REGION_EU_CENTRAL_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_EU_CENTRAL_1A
-
-config TERRAFORM_AWS_AV_ZONE_EU_CENTRAL_1A
- bool "eu-central-1a"
- help
- This option selects the eu-central-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_CENTRAL_1B
- bool "eu-central-1b"
- help
- This option selects the eu-central-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_CENTRAL_1C
- bool "eu-central-1c"
- help
- This option selects the eu-central-1c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_EU_CENTRAL_1
-
-if TERRAFORM_AWS_REGION_EU_NORTH_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_EU_NORTH_1A
-
-config TERRAFORM_AWS_AV_ZONE_EU_NORTH_1A
- bool "eu-north-1a"
- help
- This option selects the eu-north-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_NORTH_1B
- bool "eu-north-1b"
- help
- This option selects the eu-north-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_NORTH_1C
- bool "eu-north-1c"
- help
- This option selects the eu-north-1c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_EU_NORTH_1
-
-if TERRAFORM_AWS_REGION_EU_WEST_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_EU_WEST_1A
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_1A
- bool "eu-west-1a"
- help
- This option selects the eu-west-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_1B
- bool "eu-west-1b"
- help
- This option selects the eu-west-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_1C
- bool "eu-west-1c"
- help
- This option selects the eu-west-1c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_EU_WEST_1
-
-if TERRAFORM_AWS_REGION_EU_WEST_2
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_EU_WEST_2A
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_2A
- bool "eu-west-2a"
- help
- This option selects the eu-west-2a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_2B
- bool "eu-west-2b"
- help
- This option selects the eu-west-2b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_2C
- bool "eu-west-2c"
- help
- This option selects the eu-west-2c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_EU_WEST_2
-
-if TERRAFORM_AWS_REGION_EU_WEST_3
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_EU_WEST_3A
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_3A
- bool "eu-west-3a"
- help
- This option selects the eu-west-3a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_3B
- bool "eu-west-3b"
+config TERRAFORM_AWS_AVAILABILITY_ZONE
+ string "AWS availability zone"
+ depends on TERRAFORM_AWS
+ default "a"
help
- This option selects the eu-west-3b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_EU_WEST_3C
- bool "eu-west-3c"
- help
- This option selects the eu-west-3c availability zone.
-
-endchoice
+ Enter the AWS availability zone name for your region. The
+ list of supported availability zones is region-specific, so
+ to validate a particular name, use the aws client with your
+ chosen region:
-endif # TERRAFORM_AWS_REGION_EU_WEST_3
-
-if TERRAFORM_AWS_REGION_SA_EAST_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_SA_EAST_1A
-
-config TERRAFORM_AWS_AV_ZONE_SA_EAST_1A
- bool "sa-east-1a"
- help
- This option selects the sa-east-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_SA_EAST_1B
- bool "sa-east-1b"
- help
- This option selects the sa-east-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_SA_EAST_1C
- bool "sa-east-1c"
- help
- This option selects the sa-east-1c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_SA_EAST_1
-
-if TERRAFORM_AWS_REGION_US_EAST_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_US_EAST_1A
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_1A
- bool "us-east-1a"
- help
- This option selects the us-east-1a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_1B
- bool "us-east-1b"
- help
- This option selects the us-east-1b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_1C
- bool "us-east-1c"
- help
- This option selects the us-east-1c availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_1D
- bool "us-east-1d"
- help
- This option selects the us-east-1d availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_1E
- bool "us-east-1e"
- help
- This option selects the us-east-1e availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_1F
- bool "us-east-1f"
- help
- This option selects the us-east-1f availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_US_EAST_1
-
-if TERRAFORM_AWS_REGION_US_EAST_2
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_US_EAST_2A
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_2A
- bool "us-east-2a"
- help
- This option selects the us-east-2a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_2B
- bool "us-east-2b"
- help
- This option selects the us-east-2a availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_EAST_2C
- bool "us-east-2c"
- help
- This option selects the us-east-2c availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_US_EAST_2
-
-if TERRAFORM_AWS_REGION_US_WEST_1
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_US_WEST_1B
- help
- This option sets the AWS availablity zone to the specified value.
- If you wish to expand on this list send a patch after reading this
- list:
-
- https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html
- https://gist.github.com/neilstuartcraig/0ccefcf0887f29b7f240
-
-config TERRAFORM_AWS_AV_ZONE_US_WEST_1B
- bool "us-west-1b"
- help
- This option selects the us-west-1b availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_US_WEST_1
-
-if TERRAFORM_AWS_REGION_US_WEST_2
-
-choice
- prompt "AWS availability zone"
- default TERRAFORM_AWS_AV_ZONE_US_WEST_2B
- help
- This option sets the AWS availablity zone to the specified value.
- If you wish to expand on this list send a patch after reading this
- list:
-
- https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html
- https://gist.github.com/neilstuartcraig/0ccefcf0887f29b7f240
-
-config TERRAFORM_AWS_AV_ZONE_US_WEST_2B
- bool "us-west-2b"
- help
- This option selects the us-west-2b availability zone.
-
-config TERRAFORM_AWS_AV_ZONE_US_WEST_2D
- bool "us-west-2d"
- help
- This option selects the us-west-2d availability zone.
-
-endchoice
-
-endif # TERRAFORM_AWS_REGION_US_WEST_2
+ aws ec2 describe-availability-zones --region <region-name>
-config TERRAFORM_AWS_AV_ZONE
- string
- output yaml
- default "ap-northeast-1a" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_1A
- default "ap-northeast-1c" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_1C
- default "ap-northeast-1d" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_1D
- default "ap-northeast-2a" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2A
- default "ap-northeast-2b" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2B
- default "ap-northeast-2c" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2C
- default "ap-northeast-2d" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_2D
- default "ap-northeast-3a" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_3A
- default "ap-northeast-3b" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_3B
- default "ap-northeast-3c" if TERRAFORM_AWS_AV_ZONE_AP_NORTHEAST_3C
- default "ap-south-1a" if TERRAFORM_AWS_AV_ZONE_AP_SOUTH_1A
- default "ap-south-1b" if TERRAFORM_AWS_AV_ZONE_AP_SOUTH_1B
- default "ap-south-1c" if TERRAFORM_AWS_AV_ZONE_AP_SOUTH_1C
- default "ap-southeast-1a" if TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_1A
- default "ap-southeast-1b" if TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_1B
- default "ap-southeast-1c" if TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_1C
- default "ap-southeast-2a" if TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_2A
- default "ap-southeast-2b" if TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_2B
- default "ap-southeast-2c" if TERRAFORM_AWS_AV_ZONE_AP_SOUTHEAST_2C
- default "ca-central-1a" if TERRAFORM_AWS_AV_ZONE_CA_CENTRAL_1A
- default "ca-central-1b" if TERRAFORM_AWS_AV_ZONE_CA_CENTRAL_1B
- default "ca-central-1d" if TERRAFORM_AWS_AV_ZONE_CA_CENTRAL_1D
- default "eu-central-1a" if TERRAFORM_AWS_AV_ZONE_EU_CENTRAL_1A
- default "eu-central-1b" if TERRAFORM_AWS_AV_ZONE_EU_CENTRAL_1B
- default "eu-central-1c" if TERRAFORM_AWS_AV_ZONE_EU_CENTRAL_1C
- default "eu-north-1a" if TERRAFORM_AWS_AV_ZONE_EU_NORTH_1A
- default "eu-north-1b" if TERRAFORM_AWS_AV_ZONE_EU_NORTH_1B
- default "eu-north-1c" if TERRAFORM_AWS_AV_ZONE_EU_NORTH_1C
- default "eu-west-1a" if TERRAFORM_AWS_AV_ZONE_EU_WEST_1A
- default "eu-west-1b" if TERRAFORM_AWS_AV_ZONE_EU_WEST_1B
- default "eu-west-1c" if TERRAFORM_AWS_AV_ZONE_EU_WEST_1C
- default "eu-west-2a" if TERRAFORM_AWS_AV_ZONE_EU_WEST_2A
- default "eu-west-2b" if TERRAFORM_AWS_AV_ZONE_EU_WEST_2B
- default "eu-west-2c" if TERRAFORM_AWS_AV_ZONE_EU_WEST_2C
- default "eu-west-3a" if TERRAFORM_AWS_AV_ZONE_EU_WEST_3A
- default "eu-west-3b" if TERRAFORM_AWS_AV_ZONE_EU_WEST_3B
- default "eu-west-3c" if TERRAFORM_AWS_AV_ZONE_EU_WEST_3C
- default "sa-east-1a" if TERRAFORM_AWS_AV_ZONE_SA_EAST_1A
- default "sa-east-1b" if TERRAFORM_AWS_AV_ZONE_SA_EAST_1B
- default "sa-east-1c" if TERRAFORM_AWS_AV_ZONE_SA_EAST_1C
- default "us-east-1a" if TERRAFORM_AWS_AV_ZONE_US_EAST_1A
- default "us-east-1b" if TERRAFORM_AWS_AV_ZONE_US_EAST_1B
- default "us-east-1c" if TERRAFORM_AWS_AV_ZONE_US_EAST_1C
- default "us-east-1d" if TERRAFORM_AWS_AV_ZONE_US_EAST_1D
- default "us-east-1e" if TERRAFORM_AWS_AV_ZONE_US_EAST_1E
- default "us-east-1f" if TERRAFORM_AWS_AV_ZONE_US_EAST_1F
- default "us-east-2a" if TERRAFORM_AWS_AV_ZONE_US_EAST_2A
- default "us-east-2b" if TERRAFORM_AWS_AV_ZONE_US_EAST_2B
- default "us-east-2c" if TERRAFORM_AWS_AV_ZONE_US_EAST_2C
- default "us-west-1b" if TERRAFORM_AWS_AV_ZONE_US_WEST_1B
- default "us-west-2b" if TERRAFORM_AWS_AV_ZONE_US_WEST_2B
- default "us-west-2d" if TERRAFORM_AWS_AV_ZONE_US_WEST_2D
+ In general, AWS region names are lower-case letters only.
+ Sometimes, they include a number suffix (see us-east-2a, for
+ example).
\ No newline at end of file
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c7a b/terraform/aws/kconfigs/instance-types/Kconfig.c7a
deleted file mode 100644
index 147999d9..00000000
--- a/terraform/aws/kconfigs/instance-types/Kconfig.c7a
+++ /dev/null
@@ -1,28 +0,0 @@
-if TERRAFORM_AWS_INSTANCE_TYPE_C7A
-
-choice
- prompt "AWS instance size"
- default TERRAFORM_AWS_INSTANCE_SIZE_C7A_8XLARGE
- help
- Add storage by increasing the number of EBS volumes per
- instance.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_C7A_8XLARGE
- bool "c7a.8xlarge"
- help
- 32 core, 64 GiB RAM, EBS drives.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_C7A_METAL_48XL
- bool "c7a.metal-48xl"
- help
- 192 core, 384 GiB RAM, EBS drive.
-
-endchoice
-
-config TERRAFORM_AWS_INSTANCE_TYPE
- string
- output yaml
- default "c7a.8xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_C7A_8XLARGE
- default "c7a.metal-48xl" if TERRAFORM_AWS_INSTANCE_SIZE_C7A_METAL_48XL
-
-endif # TERRAFORM_AWS_INSTANCE_TYPE_C7A
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i4i b/terraform/aws/kconfigs/instance-types/Kconfig.i4i
deleted file mode 100644
index 3f7b2218..00000000
--- a/terraform/aws/kconfigs/instance-types/Kconfig.i4i
+++ /dev/null
@@ -1,33 +0,0 @@
-if TERRAFORM_AWS_INSTANCE_TYPE_I4I
-
-choice
- prompt "AWS instance type"
- default TERRAFORM_AWS_INSTANCE_SIZE_I4I_4XLARGE
-
-config TERRAFORM_AWS_INSTANCE_SIZE_I4I_LARGE
- bool "i4i.large"
- help
- 16 GiB RAM, 2 vcpus, 1 x 468 AWS Nitro SSD, 10 Gbps Net, 10 Gbps EBS.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_I4I_4XLARGE
- bool "i4i.4xlarge"
- help
- 128 GiB RAM, 16 vcpus, 1 x 3,750 AWS Nitro SSD, 25 Gbps Net,
- 10 Gbps EBS.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_I4I_METAL
- bool "i4i.metal"
- help
- 1024 GiB RAM, 128 real cpus?, 8 x 3,750 AWS Nitro SSD,
- 75 Gbps Net, 40 Gbps EBS. The bees' knees I guess.
-
-endchoice
-
-config TERRAFORM_AWS_INSTANCE_TYPE
- string
- output yaml
- default "i4i.large" if TERRAFORM_AWS_INSTANCE_SIZE_I4I_LARGE
- default "i4i.4xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_I4I_4XLARGE
- default "i4i.metal" if TERRAFORM_AWS_INSTANCE_SIZE_I4I_METAL
-
-endif # TERRAFORM_AWS_INSTANCE_TYPE_I4I
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.im4gn b/terraform/aws/kconfigs/instance-types/Kconfig.im4gn
deleted file mode 100644
index e224bdca..00000000
--- a/terraform/aws/kconfigs/instance-types/Kconfig.im4gn
+++ /dev/null
@@ -1,25 +0,0 @@
-if TERRAFORM_AWS_INSTANCE_TYPE_IM4GN
-
-choice
- prompt "AWS instance size"
- default TERRAFORM_AWS_INSTANCE_SIZE_IM4GN_LARGE
-
-config TERRAFORM_AWS_INSTANCE_SIZE_IM4GN_LARGE
- bool "im4gn.large"
- help
- 8 GiB RAM, 2vCPUs, 1 x 937 GiB NVMe SSD, 25 Gbps Net, 9.5 Gbps EBS.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_IM4GN_4XLARGE
- bool "im4gn.4xlarge"
- help
- 64 GiB RAM, 16 vcpus, 1 x 7500 NVMe SSD, 25 Gbps Net, 9.5 Gbps EBS.
-
-endchoice
-
-config TERRAFORM_AWS_INSTANCE_TYPE
- string
- output yaml
- default "im4gn.large" if TERRAFORM_AWS_INSTANCE_SIZE_IM4GN_LARGE
- default "im4gn.4xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_IM4GN_4XLARGE
-
-endif # TERRAFORM_AWS_INSTANCE_TYPE_IM4GN
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.is4gen b/terraform/aws/kconfigs/instance-types/Kconfig.is4gen
deleted file mode 100644
index 4fdca17b..00000000
--- a/terraform/aws/kconfigs/instance-types/Kconfig.is4gen
+++ /dev/null
@@ -1,25 +0,0 @@
-if TERRAFORM_AWS_INSTANCE_TYPE_IS4GEN
-
-choice
- prompt "AWS instance size"
- default TERRAFORM_AWS_INSTANCE_SIZE_IS4GEN_MEDIUM
-
-config TERRAFORM_AWS_INSTANCE_SIZE_IS4GEN_MEDIUM
- bool "is4gen.medium"
- help
- 6 GiB RAM, 1vCPU, 1 x 937 GiB NVMe SSD, 25 Gbps Net, 9.6 Gbps EBS.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_IS4GEN_8XLARGE
- bool "is4gen.8xlarge"
- help
- 192 GiB RAM, 32 vCPUs, 4 x 7500 NVMe SSD, 50 Gbps Net, 19 Gbps EBS.
-
-endchoice
-
-config TERRAFORM_AWS_INSTANCE_TYPE
- string
- output yaml
- default "is4gen.medium" if TERRAFORM_AWS_INSTANCE_SIZE_IS4GEN_MEDIUM
- default "is4gen.8xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_IS4GEN_8XLARGE
-
-endif # TERRAFORM_AWS_INSTANCE_TYPE_IS4GEN
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5 b/terraform/aws/kconfigs/instance-types/Kconfig.m5
deleted file mode 100644
index 534a20e7..00000000
--- a/terraform/aws/kconfigs/instance-types/Kconfig.m5
+++ /dev/null
@@ -1,48 +0,0 @@
-if TERRAFORM_AWS_INSTANCE_TYPE_M5
-
-choice
- prompt "AWS instance type"
- default TERRAFORM_AWS_INSTANCE_SIZE_M5AD_4XLARGE
- help
- Add storage by increasing the number of EBS volumes per
- instance.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M5AD_LARGE
- bool "m5ad.large"
- depends on TARGET_ARCH_X86_64
- help
- 8 GiB RAM, 2 AMD vcpus, 1 10 GiB main drive, up to 10 Gbps
- network speed, and one 75 GiB NVMe drive.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M5AD_XLARGE
- bool "m5ad.xlarge"
- depends on TARGET_ARCH_X86_64
- help
- 16 GiB RAM, 4 AMD vcpus, 1 10 GiB main drive, up to 10 Gbps
- network speed, and one 150 GiB NVMe drive.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M5AD_2XLARGE
- bool "m5ad.2xlarge"
- depends on TARGET_ARCH_X86_64
- help
- 32 GiB RAM, 8 AMD vcpus, 1 10 GiB main drive, up to 10 Gbps
- network speed, and one 300 GiB NVMe drive.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M5AD_4XLARGE
- bool "m5ad.4xlarge"
- depends on TARGET_ARCH_X86_64
- help
- 64 GiB RAM, 16 AMD vcpus, 1 10 GiB main drive, up to 10 Gbps
- and two 300 GiB NVMe drives.
-
-endchoice
-
-config TERRAFORM_AWS_INSTANCE_TYPE
- string
- output yaml
- default "m5ad.large" if TERRAFORM_AWS_INSTANCE_SIZE_M5AD_LARGE
- default "m5ad.xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_M5AD_XLARGE
- default "m5ad.2xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_M5AD_2XLARGE
- default "m5ad.4xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_M5AD_4XLARGE
-
-endif # TERRAFORM_AWS_INSTANCE_TYPE_M5
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m7a b/terraform/aws/kconfigs/instance-types/Kconfig.m7a
deleted file mode 100644
index fd7bd6f4..00000000
--- a/terraform/aws/kconfigs/instance-types/Kconfig.m7a
+++ /dev/null
@@ -1,57 +0,0 @@
-if TERRAFORM_AWS_INSTANCE_TYPE_M7A
-
-choice
- prompt "AWS instance type"
- default TERRAFORM_AWS_INSTANCE_SIZE_M7A_XLARGE
- help
- Add storage by increasing the number of EBS volumes per
- instance.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M7A_MEDIUM
- bool "m7a.medium"
- depends on TARGET_ARCH_X86_64
- help
- 4 GiB RAM, 1 AMD Ryzen vcpu, 1 10 GiB main drive, and up to
- 12.5 Gbs network speed.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M7A_LARGE
- bool "m7a.large"
- depends on TARGET_ARCH_X86_64
- help
- 8 GiB RAM, 2 AMD Ryzen vcpus, 1 10 GiB main drive, and up to
- 12.5 Gbs network speed.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M7A_XLARGE
- bool "m7a.xlarge"
- depends on TARGET_ARCH_X86_64
- help
- 16 GiB RAM, 4 AMD Ryzen vcpus, 1 10 GiB main drive, and up to
- 12.5 Gbs network speed.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M7A_2XLARGE
- bool "m7a.2xlarge"
- depends on TARGET_ARCH_X86_64
- help
- 32 GiB RAM, 8 AMD Ryzen vcpus, 1 10 GiB main drive, and up to
- 12.5 Gbs network speed.
-
-config TERRAFORM_AWS_INSTANCE_SIZE_M7A_4XLARGE
- bool "m7a.4xlarge"
- depends on TARGET_ARCH_X86_64
- help
- 64 GiB RAM, 16 AMD Ryzen vcpus, 1 10 GiB main drive, and up to
- 12.5 Gbs network speed.
-
-endchoice
-
-config TERRAFORM_AWS_INSTANCE_TYPE
- string
- output yaml
- default "m7a.medium" if TERRAFORM_AWS_INSTANCE_SIZE_M7A_MEDIUM
- default "m7a.large" if TERRAFORM_AWS_INSTANCE_SIZE_M7A_LARGE
- default "m7a.xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_M7A_XLARGE
- default "m7a.xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_M7A_XLARGE
- default "m7a.2xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_M7A_2XLARGE
- default "m7a.4xlarge" if TERRAFORM_AWS_INSTANCE_SIZE_M7A_4XLARGE
-
-endif # TERRAFORM_AWS_INSTANCE_TYPE_M7A
--
2.50.1
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH v3 3/3] cloud: run make cloud-update
2025-09-09 0:56 [PATCH v3 0/3] aws: add dynamic kconfig support Luis Chamberlain
2025-09-09 0:56 ` [PATCH v3 1/3] aws: add dynamic cloud configuration support Luis Chamberlain
2025-09-09 0:56 ` [PATCH v3 2/3] aws: enable GPU AMI support for GPU instances Luis Chamberlain
@ 2025-09-09 0:56 ` Luis Chamberlain
2025-09-10 14:48 ` [PATCH v3 0/3] aws: add dynamic kconfig support Chuck Lever
3 siblings, 0 replies; 6+ messages in thread
From: Luis Chamberlain @ 2025-09-09 0:56 UTC (permalink / raw)
To: Chuck Lever, Daniel Gomez, kdevops; +Cc: Luis Chamberlain
We then commit all changes.
Signed-off-by: Luis Chamberlain <mcgrof@kernel.org>
---
terraform/aws/kconfigs/Kconfig.compute.static | 1885 +++++++++++++++++
.../aws/kconfigs/Kconfig.gpu-amis.static | 79 +
.../aws/kconfigs/Kconfig.location.static | 124 ++
.../kconfigs/instance-types/Kconfig.a1.static | 68 +
.../kconfigs/instance-types/Kconfig.c1.static | 34 +
.../kconfigs/instance-types/Kconfig.c3.static | 64 +
.../kconfigs/instance-types/Kconfig.c4.static | 59 +
.../kconfigs/instance-types/Kconfig.c5.static | 95 +
.../instance-types/Kconfig.c5a.static | 86 +
.../instance-types/Kconfig.c5ad.static | 94 +
.../instance-types/Kconfig.c5d.static | 104 +
.../instance-types/Kconfig.c5n.static | 77 +
.../instance-types/Kconfig.c6a.static | 113 +
.../instance-types/Kconfig.c6g.static | 95 +
.../instance-types/Kconfig.c6gd.static | 104 +
.../instance-types/Kconfig.c6gn.static | 86 +
.../instance-types/Kconfig.c6i.static | 104 +
.../instance-types/Kconfig.c6id.static | 114 +
.../instance-types/Kconfig.c6in.static | 104 +
.../instance-types/Kconfig.c7a.static | 122 ++
.../instance-types/Kconfig.c7g.static | 95 +
.../instance-types/Kconfig.c7gd.static | 104 +
.../instance-types/Kconfig.c7gn.static | 95 +
.../instance-types/Kconfig.c7i-flex.static | 77 +
.../instance-types/Kconfig.c7i.static | 113 +
.../instance-types/Kconfig.c8g.static | 122 ++
.../instance-types/Kconfig.c8gd.static | 134 ++
.../instance-types/Kconfig.c8gn.static | 122 ++
.../kconfigs/instance-types/Kconfig.d2.static | 54 +
.../kconfigs/instance-types/Kconfig.d3.static | 54 +
.../instance-types/Kconfig.d3en.static | 74 +
.../instance-types/Kconfig.dl1.static | 24 +
.../kconfigs/instance-types/Kconfig.f1.static | 44 +
.../kconfigs/instance-types/Kconfig.f2.static | 44 +
.../instance-types/Kconfig.g4ad.static | 64 +
.../instance-types/Kconfig.g4dn.static | 84 +
.../kconfigs/instance-types/Kconfig.g5.static | 94 +
.../instance-types/Kconfig.g5g.static | 68 +
.../kconfigs/instance-types/Kconfig.g6.static | 94 +
.../instance-types/Kconfig.g6e.static | 94 +
.../instance-types/Kconfig.g6f.static | 54 +
.../instance-types/Kconfig.gr6.static | 34 +
.../instance-types/Kconfig.gr6f.static | 24 +
.../kconfigs/instance-types/Kconfig.h1.static | 54 +
.../instance-types/Kconfig.hpc7g.static | 41 +
.../kconfigs/instance-types/Kconfig.i2.static | 54 +
.../kconfigs/instance-types/Kconfig.i3.static | 74 +
.../instance-types/Kconfig.i3en.static | 94 +
.../instance-types/Kconfig.i4g.static | 74 +
.../instance-types/Kconfig.i4i.static | 114 +
.../instance-types/Kconfig.i7i.static | 124 ++
.../instance-types/Kconfig.i7ie.static | 124 ++
.../instance-types/Kconfig.i8g.static | 114 +
.../instance-types/Kconfig.i8ge.static | 124 ++
.../instance-types/Kconfig.im4gn.static | 74 +
.../instance-types/Kconfig.inf1.static | 50 +
.../instance-types/Kconfig.inf2.static | 50 +
.../instance-types/Kconfig.is4gen.static | 74 +
.../kconfigs/instance-types/Kconfig.m1.static | 54 +
.../kconfigs/instance-types/Kconfig.m2.static | 44 +
.../kconfigs/instance-types/Kconfig.m3.static | 54 +
.../kconfigs/instance-types/Kconfig.m4.static | 68 +
.../kconfigs/instance-types/Kconfig.m5.static | 95 +
.../instance-types/Kconfig.m5a.static | 86 +
.../instance-types/Kconfig.m5ad.static | 94 +
.../instance-types/Kconfig.m5d.static | 104 +
.../instance-types/Kconfig.m5dn.static | 104 +
.../instance-types/Kconfig.m5n.static | 95 +
.../instance-types/Kconfig.m5zn.static | 77 +
.../instance-types/Kconfig.m6a.static | 113 +
.../instance-types/Kconfig.m6g.static | 95 +
.../instance-types/Kconfig.m6gd.static | 104 +
.../instance-types/Kconfig.m6i.static | 104 +
.../instance-types/Kconfig.m6id.static | 114 +
.../instance-types/Kconfig.m6idn.static | 114 +
.../instance-types/Kconfig.m6in.static | 104 +
.../instance-types/Kconfig.m7a.static | 122 ++
.../instance-types/Kconfig.m7g.static | 95 +
.../instance-types/Kconfig.m7gd.static | 104 +
.../instance-types/Kconfig.m7i-flex.static | 77 +
.../instance-types/Kconfig.m7i.static | 113 +
.../instance-types/Kconfig.m8g.static | 122 ++
.../instance-types/Kconfig.m8gd.static | 134 ++
.../instance-types/Kconfig.m8i-flex.static | 77 +
.../instance-types/Kconfig.m8i.static | 131 ++
.../instance-types/Kconfig.mac1.static | 23 +
.../Kconfig.mac2-m1ultra.static | 23 +
.../instance-types/Kconfig.mac2-m2.static | 23 +
.../instance-types/Kconfig.mac2-m2pro.static | 23 +
.../instance-types/Kconfig.mac2.static | 23 +
.../kconfigs/instance-types/Kconfig.p3.static | 41 +
.../instance-types/Kconfig.p3dn.static | 24 +
.../instance-types/Kconfig.p4d.static | 24 +
.../instance-types/Kconfig.p4de.static | 24 +
.../kconfigs/instance-types/Kconfig.p5.static | 34 +
.../instance-types/Kconfig.p5en.static | 24 +
.../instance-types/Kconfig.p6-b200.static | 24 +
.../kconfigs/instance-types/Kconfig.r3.static | 64 +
.../kconfigs/instance-types/Kconfig.r4.static | 68 +
.../kconfigs/instance-types/Kconfig.r5.static | 95 +
.../instance-types/Kconfig.r5a.static | 86 +
.../instance-types/Kconfig.r5ad.static | 94 +
.../instance-types/Kconfig.r5b.static | 95 +
.../instance-types/Kconfig.r5d.static | 104 +
.../instance-types/Kconfig.r5dn.static | 104 +
.../instance-types/Kconfig.r5n.static | 95 +
.../instance-types/Kconfig.r6a.static | 113 +
.../instance-types/Kconfig.r6g.static | 95 +
.../instance-types/Kconfig.r6gd.static | 104 +
.../instance-types/Kconfig.r6i.static | 104 +
.../instance-types/Kconfig.r6id.static | 114 +
.../instance-types/Kconfig.r6idn.static | 114 +
.../instance-types/Kconfig.r6in.static | 104 +
.../instance-types/Kconfig.r7a.static | 122 ++
.../instance-types/Kconfig.r7g.static | 95 +
.../instance-types/Kconfig.r7gd.static | 104 +
.../instance-types/Kconfig.r7i.static | 113 +
.../instance-types/Kconfig.r7iz.static | 104 +
.../instance-types/Kconfig.r8g.static | 122 ++
.../instance-types/Kconfig.r8gd.static | 134 ++
.../instance-types/Kconfig.r8i-flex.static | 77 +
.../instance-types/Kconfig.r8i.static | 131 ++
.../kconfigs/instance-types/Kconfig.t1.static | 23 +
.../kconfigs/instance-types/Kconfig.t2.static | 77 +
.../kconfigs/instance-types/Kconfig.t3.static | 77 +
.../instance-types/Kconfig.t3a.static | 77 +
.../instance-types/Kconfig.t4g.static | 77 +
.../instance-types/Kconfig.trn1.static | 34 +
.../instance-types/Kconfig.trn1n.static | 24 +
.../instance-types/Kconfig.u-3tb1.static | 23 +
.../instance-types/Kconfig.u-6tb1.static | 32 +
.../instance-types/Kconfig.u7i-12tb.static | 23 +
.../instance-types/Kconfig.u7i-6tb.static | 23 +
.../instance-types/Kconfig.u7i-8tb.static | 23 +
.../instance-types/Kconfig.u7in-16tb.static | 23 +
.../instance-types/Kconfig.u7in-24tb.static | 23 +
.../instance-types/Kconfig.u7in-32tb.static | 23 +
.../instance-types/Kconfig.vt1.static | 41 +
.../kconfigs/instance-types/Kconfig.x1.static | 34 +
.../instance-types/Kconfig.x1e.static | 74 +
.../instance-types/Kconfig.x2gd.static | 104 +
.../instance-types/Kconfig.x2idn.static | 54 +
.../instance-types/Kconfig.x2iedn.static | 94 +
.../instance-types/Kconfig.x2iezn.static | 68 +
.../instance-types/Kconfig.x8g.static | 122 ++
.../instance-types/Kconfig.z1d.static | 84 +
.../kconfigs/Kconfig.compute.static | 195 ++
.../lambdalabs/kconfigs/Kconfig.images.static | 0
.../kconfigs/Kconfig.location.static | 59 +
149 files changed, 13590 insertions(+)
create mode 100644 terraform/aws/kconfigs/Kconfig.compute.static
create mode 100644 terraform/aws/kconfigs/Kconfig.gpu-amis.static
create mode 100644 terraform/aws/kconfigs/Kconfig.location.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.a1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c3.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c4.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c5.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c5a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c5ad.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c5d.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c5n.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c6a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c6g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c6gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c6gn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c6i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c6id.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c6in.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c7a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c7g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c7gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c7gn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c7i-flex.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c7i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c8g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c8gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.c8gn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.d2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.d3.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.d3en.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.dl1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.f1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.f2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.g4ad.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.g4dn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.g5.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.g5g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.g6.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.g6e.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.g6f.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.gr6.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.gr6f.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.h1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.hpc7g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i3.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i3en.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i4g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i4i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i7i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i7ie.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i8g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.i8ge.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.im4gn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.inf1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.inf2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.is4gen.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m3.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m4.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5ad.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5d.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5dn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5n.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m5zn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m6a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m6g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m6gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m6i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m6id.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m6idn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m6in.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m7a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m7g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m7gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m7i-flex.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m7i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m8g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m8gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m8i-flex.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.m8i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.mac1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.mac2-m1ultra.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2pro.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.mac2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.p3.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.p3dn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.p4d.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.p4de.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.p5.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.p5en.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.p6-b200.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r3.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r4.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r5.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r5a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r5ad.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r5b.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r5d.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r5dn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r5n.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r6a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r6g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r6gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r6i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r6id.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r6idn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r6in.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r7a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r7g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r7gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r7i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r7iz.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r8g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r8gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r8i-flex.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.r8i.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.t1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.t2.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.t3.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.t3a.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.t4g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.trn1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.trn1n.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u-3tb1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u-6tb1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u7i-12tb.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u7i-6tb.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u7i-8tb.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u7in-16tb.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u7in-24tb.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.u7in-32tb.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.vt1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.x1.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.x1e.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.x2gd.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.x2idn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.x2iedn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.x2iezn.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.x8g.static
create mode 100644 terraform/aws/kconfigs/instance-types/Kconfig.z1d.static
create mode 100644 terraform/lambdalabs/kconfigs/Kconfig.compute.static
create mode 100644 terraform/lambdalabs/kconfigs/Kconfig.images.static
create mode 100644 terraform/lambdalabs/kconfigs/Kconfig.location.static
diff --git a/terraform/aws/kconfigs/Kconfig.compute.static b/terraform/aws/kconfigs/Kconfig.compute.static
new file mode 100644
index 00000000..dcda5ad5
--- /dev/null
+++ b/terraform/aws/kconfigs/Kconfig.compute.static
@@ -0,0 +1,1885 @@
+# AWS instance families (dynamically generated)
+# Generated by aws-cli from live AWS data
+
+choice
+ prompt "AWS instance family"
+ default TERRAFORM_AWS_INSTANCE_TYPE_M5
+ help
+ Select the AWS instance family for your deployment.
+ Different families are optimized for different workloads.
+
+# General Purpose - balanced compute, memory, and networking
+config TERRAFORM_AWS_INSTANCE_TYPE_M1
+ bool "M1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M1 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M2
+ bool "M2"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M2 instance family
+ Available instance types: 3
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M3
+ bool "M3"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M3 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M4
+ bool "M4"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M4 instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5
+ bool "M5"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ General purpose instances powered by Intel Xeon Platinum processors
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5A
+ bool "M5A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M5A instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5AD
+ bool "M5AD"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M5AD instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5D
+ bool "M5D"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M5D instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5DN
+ bool "M5DN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M5DN instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5N
+ bool "M5N"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M5N instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M5ZN
+ bool "M5ZN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M5ZN instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M6A
+ bool "M6A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M6A instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M6G
+ bool "M6G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS M6G instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M6GD
+ bool "M6GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS M6GD instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M6I
+ bool "M6I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M6I instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M6ID
+ bool "M6ID"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M6ID instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M6IDN
+ bool "M6IDN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M6IDN instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M6IN
+ bool "M6IN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M6IN instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M7A
+ bool "M7A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ Latest generation general purpose instances powered by AMD EPYC processors
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M7G
+ bool "M7G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS M7G instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M7GD
+ bool "M7GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS M7GD instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M7I
+ bool "M7I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M7I instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M7I_FLEX
+ bool "M7I-FLEX"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M7I-FLEX instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M8G
+ bool "M8G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS M8G instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M8GD
+ bool "M8GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS M8GD instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M8I
+ bool "M8I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M8I instance family
+ Available instance types: 13
+
+config TERRAFORM_AWS_INSTANCE_TYPE_M8I_FLEX
+ bool "M8I-FLEX"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS M8I-FLEX instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_MAC1
+ bool "MAC1"
+
+ help
+ AWS MAC1 instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_MAC2
+ bool "MAC2"
+
+ help
+ AWS MAC2 instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M1ULTRA
+ bool "MAC2-M1ULTRA"
+
+ help
+ AWS MAC2-M1ULTRA instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M2
+ bool "MAC2-M2"
+
+ help
+ AWS MAC2-M2 instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M2PRO
+ bool "MAC2-M2PRO"
+
+ help
+ AWS MAC2-M2PRO instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_T1
+ bool "T1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS T1 instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_T2
+ bool "T2"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS T2 instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_T3
+ bool "T3"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ Burstable performance instances powered by Intel processors
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_T3A
+ bool "T3A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ Burstable performance instances powered by AMD processors
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_T4G
+ bool "T4G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS T4G instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_TRN1
+ bool "TRN1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS TRN1 instance family
+ Available instance types: 2
+
+config TERRAFORM_AWS_INSTANCE_TYPE_TRN1N
+ bool "TRN1N"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS TRN1N instance family
+ Available instance types: 1
+
+
+# Compute Optimized - ideal for CPU-intensive applications
+config TERRAFORM_AWS_INSTANCE_TYPE_C1
+ bool "C1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C1 instance family
+ Available instance types: 2
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C3
+ bool "C3"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C3 instance family
+ Available instance types: 5
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C4
+ bool "C4"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C4 instance family
+ Available instance types: 5
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C5
+ bool "C5"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ Compute optimized instances powered by Intel Xeon Platinum processors
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C5A
+ bool "C5A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C5A instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C5AD
+ bool "C5AD"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C5AD instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C5D
+ bool "C5D"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C5D instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C5N
+ bool "C5N"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C5N instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C6A
+ bool "C6A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C6A instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C6G
+ bool "C6G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C6G instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C6GD
+ bool "C6GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C6GD instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C6GN
+ bool "C6GN"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C6GN instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C6I
+ bool "C6I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C6I instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C6ID
+ bool "C6ID"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C6ID instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C6IN
+ bool "C6IN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C6IN instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C7A
+ bool "C7A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ Latest generation compute optimized instances powered by AMD EPYC processors
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C7G
+ bool "C7G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C7G instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C7GD
+ bool "C7GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C7GD instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C7GN
+ bool "C7GN"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C7GN instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C7I
+ bool "C7I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C7I instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C7I_FLEX
+ bool "C7I-FLEX"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS C7I-FLEX instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C8G
+ bool "C8G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C8G instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C8GD
+ bool "C8GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C8GD instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_C8GN
+ bool "C8GN"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS C8GN instance family
+ Available instance types: 12
+
+
+# Memory Optimized - for memory-intensive applications
+config TERRAFORM_AWS_INSTANCE_TYPE_R3
+ bool "R3"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R3 instance family
+ Available instance types: 5
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R4
+ bool "R4"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R4 instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R5
+ bool "R5"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ Memory optimized instances powered by Intel Xeon Platinum processors
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R5A
+ bool "R5A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R5A instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R5AD
+ bool "R5AD"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R5AD instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R5B
+ bool "R5B"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R5B instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R5D
+ bool "R5D"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R5D instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R5DN
+ bool "R5DN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R5DN instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R5N
+ bool "R5N"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R5N instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R6A
+ bool "R6A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R6A instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R6G
+ bool "R6G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS R6G instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R6GD
+ bool "R6GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS R6GD instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R6I
+ bool "R6I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R6I instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R6ID
+ bool "R6ID"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R6ID instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R6IDN
+ bool "R6IDN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R6IDN instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R6IN
+ bool "R6IN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R6IN instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R7A
+ bool "R7A"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R7A instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R7G
+ bool "R7G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS R7G instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R7GD
+ bool "R7GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS R7GD instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R7I
+ bool "R7I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R7I instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R7IZ
+ bool "R7IZ"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R7IZ instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R8G
+ bool "R8G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS R8G instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R8GD
+ bool "R8GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS R8GD instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R8I
+ bool "R8I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R8I instance family
+ Available instance types: 13
+
+config TERRAFORM_AWS_INSTANCE_TYPE_R8I_FLEX
+ bool "R8I-FLEX"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS R8I-FLEX instance family
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_X1
+ bool "X1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS X1 instance family
+ Available instance types: 2
+
+config TERRAFORM_AWS_INSTANCE_TYPE_X1E
+ bool "X1E"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS X1E instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_X2GD
+ bool "X2GD"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS X2GD instance family
+ Available instance types: 9
+
+config TERRAFORM_AWS_INSTANCE_TYPE_X2IDN
+ bool "X2IDN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS X2IDN instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_X2IEDN
+ bool "X2IEDN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS X2IEDN instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_X2IEZN
+ bool "X2IEZN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS X2IEZN instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_X8G
+ bool "X8G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS X8G instance family
+ Available instance types: 12
+
+config TERRAFORM_AWS_INSTANCE_TYPE_Z1D
+ bool "Z1D"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS Z1D instance family
+ Available instance types: 7
+
+
+# Storage Optimized - for high sequential read/write workloads
+config TERRAFORM_AWS_INSTANCE_TYPE_D2
+ bool "D2"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS D2 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_D3
+ bool "D3"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS D3 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_D3EN
+ bool "D3EN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS D3EN instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_DL1
+ bool "DL1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS DL1 instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_H1
+ bool "H1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS H1 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_HPC7G
+ bool "HPC7G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS HPC7G instance family
+ Available instance types: 3
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I2
+ bool "I2"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS I2 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I3
+ bool "I3"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS I3 instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I3EN
+ bool "I3EN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS I3EN instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I4G
+ bool "I4G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS I4G instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I4I
+ bool "I4I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ Storage optimized instances with NVMe SSD storage
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I7I
+ bool "I7I"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS I7I instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I7IE
+ bool "I7IE"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS I7IE instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I8G
+ bool "I8G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS I8G instance family
+ Available instance types: 10
+
+config TERRAFORM_AWS_INSTANCE_TYPE_I8GE
+ bool "I8GE"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS I8GE instance family
+ Available instance types: 11
+
+config TERRAFORM_AWS_INSTANCE_TYPE_IM4GN
+ bool "IM4GN"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ Storage optimized ARM instances with NVMe storage
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_INF1
+ bool "INF1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS INF1 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_INF2
+ bool "INF2"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS INF2 instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_IS4GEN
+ bool "IS4GEN"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ Storage optimized ARM instances powered by AWS Graviton2
+ Available instance types: 6
+
+
+# Accelerated Computing - GPU and other accelerators
+config TERRAFORM_AWS_INSTANCE_TYPE_F1
+ bool "F1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS F1 instance family
+ Available instance types: 3
+
+config TERRAFORM_AWS_INSTANCE_TYPE_F2
+ bool "F2"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS F2 instance family
+ Available instance types: 3
+
+config TERRAFORM_AWS_INSTANCE_TYPE_G4AD
+ bool "G4AD"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS G4AD instance family
+ Available instance types: 5
+
+config TERRAFORM_AWS_INSTANCE_TYPE_G4DN
+ bool "G4DN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ GPU instances for graphics-intensive applications
+ Available instance types: 7
+
+config TERRAFORM_AWS_INSTANCE_TYPE_G5
+ bool "G5"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS G5 instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_G5G
+ bool "G5G"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS G5G instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_G6
+ bool "G6"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS G6 instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_G6E
+ bool "G6E"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS G6E instance family
+ Available instance types: 8
+
+config TERRAFORM_AWS_INSTANCE_TYPE_G6F
+ bool "G6F"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS G6F instance family
+ Available instance types: 4
+
+config TERRAFORM_AWS_INSTANCE_TYPE_GR6
+ bool "GR6"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS GR6 instance family
+ Available instance types: 2
+
+config TERRAFORM_AWS_INSTANCE_TYPE_GR6F
+ bool "GR6F"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS GR6F instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_P3
+ bool "P3"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ GPU instances for machine learning and HPC
+ Available instance types: 3
+
+config TERRAFORM_AWS_INSTANCE_TYPE_P3DN
+ bool "P3DN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS P3DN instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_P4D
+ bool "P4D"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS P4D instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_P4DE
+ bool "P4DE"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS P4DE instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_P5
+ bool "P5"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS P5 instance family
+ Available instance types: 2
+
+config TERRAFORM_AWS_INSTANCE_TYPE_P5EN
+ bool "P5EN"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS P5EN instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_P6_B200
+ bool "P6-B200"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS P6-B200 instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_VT1
+ bool "VT1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS VT1 instance family
+ Available instance types: 3
+
+
+# Other instance families
+config TERRAFORM_AWS_INSTANCE_TYPE_A1
+ bool "A1"
+
+ depends on TARGET_ARCH_ARM64
+ help
+ AWS A1 instance family
+ Available instance types: 6
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U_3TB1
+ bool "U-3TB1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U-3TB1 instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U_6TB1
+ bool "U-6TB1"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U-6TB1 instance family
+ Available instance types: 2
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U7I_12TB
+ bool "U7I-12TB"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U7I-12TB instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U7I_6TB
+ bool "U7I-6TB"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U7I-6TB instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U7I_8TB
+ bool "U7I-8TB"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U7I-8TB instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U7IN_16TB
+ bool "U7IN-16TB"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U7IN-16TB instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U7IN_24TB
+ bool "U7IN-24TB"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U7IN-24TB instance family
+ Available instance types: 1
+
+config TERRAFORM_AWS_INSTANCE_TYPE_U7IN_32TB
+ bool "U7IN-32TB"
+
+ depends on TARGET_ARCH_X86_64
+ help
+ AWS U7IN-32TB instance family
+ Available instance types: 1
+
+
+endchoice
+
+# Include instance-specific configurations
+if TERRAFORM_AWS_INSTANCE_TYPE_A1
+source "terraform/aws/kconfigs/instance-types/Kconfig.a1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C1
+source "terraform/aws/kconfigs/instance-types/Kconfig.c1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C3
+source "terraform/aws/kconfigs/instance-types/Kconfig.c3.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C4
+source "terraform/aws/kconfigs/instance-types/Kconfig.c4.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C5
+source "terraform/aws/kconfigs/instance-types/Kconfig.c5.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C5A
+source "terraform/aws/kconfigs/instance-types/Kconfig.c5a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C5AD
+source "terraform/aws/kconfigs/instance-types/Kconfig.c5ad.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C5D
+source "terraform/aws/kconfigs/instance-types/Kconfig.c5d.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C5N
+source "terraform/aws/kconfigs/instance-types/Kconfig.c5n.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C6A
+source "terraform/aws/kconfigs/instance-types/Kconfig.c6a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C6G
+source "terraform/aws/kconfigs/instance-types/Kconfig.c6g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C6GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.c6gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C6GN
+source "terraform/aws/kconfigs/instance-types/Kconfig.c6gn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C6I
+source "terraform/aws/kconfigs/instance-types/Kconfig.c6i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C6ID
+source "terraform/aws/kconfigs/instance-types/Kconfig.c6id.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C6IN
+source "terraform/aws/kconfigs/instance-types/Kconfig.c6in.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C7A
+source "terraform/aws/kconfigs/instance-types/Kconfig.c7a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C7G
+source "terraform/aws/kconfigs/instance-types/Kconfig.c7g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C7GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.c7gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C7GN
+source "terraform/aws/kconfigs/instance-types/Kconfig.c7gn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C7I
+source "terraform/aws/kconfigs/instance-types/Kconfig.c7i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C7I_FLEX
+source "terraform/aws/kconfigs/instance-types/Kconfig.c7i-flex.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C8G
+source "terraform/aws/kconfigs/instance-types/Kconfig.c8g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C8GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.c8gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_C8GN
+source "terraform/aws/kconfigs/instance-types/Kconfig.c8gn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_D2
+source "terraform/aws/kconfigs/instance-types/Kconfig.d2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_D3
+source "terraform/aws/kconfigs/instance-types/Kconfig.d3.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_D3EN
+source "terraform/aws/kconfigs/instance-types/Kconfig.d3en.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_DL1
+source "terraform/aws/kconfigs/instance-types/Kconfig.dl1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_F1
+source "terraform/aws/kconfigs/instance-types/Kconfig.f1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_F2
+source "terraform/aws/kconfigs/instance-types/Kconfig.f2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_G4AD
+source "terraform/aws/kconfigs/instance-types/Kconfig.g4ad.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_G4DN
+source "terraform/aws/kconfigs/instance-types/Kconfig.g4dn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_G5
+source "terraform/aws/kconfigs/instance-types/Kconfig.g5.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_G5G
+source "terraform/aws/kconfigs/instance-types/Kconfig.g5g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_G6
+source "terraform/aws/kconfigs/instance-types/Kconfig.g6.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_G6E
+source "terraform/aws/kconfigs/instance-types/Kconfig.g6e.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_G6F
+source "terraform/aws/kconfigs/instance-types/Kconfig.g6f.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_GR6
+source "terraform/aws/kconfigs/instance-types/Kconfig.gr6.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_GR6F
+source "terraform/aws/kconfigs/instance-types/Kconfig.gr6f.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_H1
+source "terraform/aws/kconfigs/instance-types/Kconfig.h1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_HPC7G
+source "terraform/aws/kconfigs/instance-types/Kconfig.hpc7g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I2
+source "terraform/aws/kconfigs/instance-types/Kconfig.i2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I3
+source "terraform/aws/kconfigs/instance-types/Kconfig.i3.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I3EN
+source "terraform/aws/kconfigs/instance-types/Kconfig.i3en.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I4G
+source "terraform/aws/kconfigs/instance-types/Kconfig.i4g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I4I
+source "terraform/aws/kconfigs/instance-types/Kconfig.i4i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I7I
+source "terraform/aws/kconfigs/instance-types/Kconfig.i7i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I7IE
+source "terraform/aws/kconfigs/instance-types/Kconfig.i7ie.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I8G
+source "terraform/aws/kconfigs/instance-types/Kconfig.i8g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_I8GE
+source "terraform/aws/kconfigs/instance-types/Kconfig.i8ge.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_IM4GN
+source "terraform/aws/kconfigs/instance-types/Kconfig.im4gn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_INF1
+source "terraform/aws/kconfigs/instance-types/Kconfig.inf1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_INF2
+source "terraform/aws/kconfigs/instance-types/Kconfig.inf2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_IS4GEN
+source "terraform/aws/kconfigs/instance-types/Kconfig.is4gen.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M1
+source "terraform/aws/kconfigs/instance-types/Kconfig.m1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M2
+source "terraform/aws/kconfigs/instance-types/Kconfig.m2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M3
+source "terraform/aws/kconfigs/instance-types/Kconfig.m3.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M4
+source "terraform/aws/kconfigs/instance-types/Kconfig.m4.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M5
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M5A
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M5AD
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5ad.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M5D
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5d.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M5DN
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5dn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M5N
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5n.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M5ZN
+source "terraform/aws/kconfigs/instance-types/Kconfig.m5zn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M6A
+source "terraform/aws/kconfigs/instance-types/Kconfig.m6a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M6G
+source "terraform/aws/kconfigs/instance-types/Kconfig.m6g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M6GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.m6gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M6I
+source "terraform/aws/kconfigs/instance-types/Kconfig.m6i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M6ID
+source "terraform/aws/kconfigs/instance-types/Kconfig.m6id.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M6IDN
+source "terraform/aws/kconfigs/instance-types/Kconfig.m6idn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M6IN
+source "terraform/aws/kconfigs/instance-types/Kconfig.m6in.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M7A
+source "terraform/aws/kconfigs/instance-types/Kconfig.m7a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M7G
+source "terraform/aws/kconfigs/instance-types/Kconfig.m7g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M7GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.m7gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M7I
+source "terraform/aws/kconfigs/instance-types/Kconfig.m7i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M7I_FLEX
+source "terraform/aws/kconfigs/instance-types/Kconfig.m7i-flex.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M8G
+source "terraform/aws/kconfigs/instance-types/Kconfig.m8g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M8GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.m8gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M8I
+source "terraform/aws/kconfigs/instance-types/Kconfig.m8i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_M8I_FLEX
+source "terraform/aws/kconfigs/instance-types/Kconfig.m8i-flex.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_MAC1
+source "terraform/aws/kconfigs/instance-types/Kconfig.mac1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_MAC2
+source "terraform/aws/kconfigs/instance-types/Kconfig.mac2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M1ULTRA
+source "terraform/aws/kconfigs/instance-types/Kconfig.mac2-m1ultra.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M2
+source "terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M2PRO
+source "terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2pro.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_P3
+source "terraform/aws/kconfigs/instance-types/Kconfig.p3.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_P3DN
+source "terraform/aws/kconfigs/instance-types/Kconfig.p3dn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_P4D
+source "terraform/aws/kconfigs/instance-types/Kconfig.p4d.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_P4DE
+source "terraform/aws/kconfigs/instance-types/Kconfig.p4de.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_P5
+source "terraform/aws/kconfigs/instance-types/Kconfig.p5.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_P5EN
+source "terraform/aws/kconfigs/instance-types/Kconfig.p5en.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_P6_B200
+source "terraform/aws/kconfigs/instance-types/Kconfig.p6-b200.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R3
+source "terraform/aws/kconfigs/instance-types/Kconfig.r3.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R4
+source "terraform/aws/kconfigs/instance-types/Kconfig.r4.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R5
+source "terraform/aws/kconfigs/instance-types/Kconfig.r5.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R5A
+source "terraform/aws/kconfigs/instance-types/Kconfig.r5a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R5AD
+source "terraform/aws/kconfigs/instance-types/Kconfig.r5ad.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R5B
+source "terraform/aws/kconfigs/instance-types/Kconfig.r5b.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R5D
+source "terraform/aws/kconfigs/instance-types/Kconfig.r5d.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R5DN
+source "terraform/aws/kconfigs/instance-types/Kconfig.r5dn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R5N
+source "terraform/aws/kconfigs/instance-types/Kconfig.r5n.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R6A
+source "terraform/aws/kconfigs/instance-types/Kconfig.r6a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R6G
+source "terraform/aws/kconfigs/instance-types/Kconfig.r6g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R6GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.r6gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R6I
+source "terraform/aws/kconfigs/instance-types/Kconfig.r6i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R6ID
+source "terraform/aws/kconfigs/instance-types/Kconfig.r6id.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R6IDN
+source "terraform/aws/kconfigs/instance-types/Kconfig.r6idn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R6IN
+source "terraform/aws/kconfigs/instance-types/Kconfig.r6in.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R7A
+source "terraform/aws/kconfigs/instance-types/Kconfig.r7a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R7G
+source "terraform/aws/kconfigs/instance-types/Kconfig.r7g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R7GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.r7gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R7I
+source "terraform/aws/kconfigs/instance-types/Kconfig.r7i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R7IZ
+source "terraform/aws/kconfigs/instance-types/Kconfig.r7iz.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R8G
+source "terraform/aws/kconfigs/instance-types/Kconfig.r8g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R8GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.r8gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R8I
+source "terraform/aws/kconfigs/instance-types/Kconfig.r8i.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_R8I_FLEX
+source "terraform/aws/kconfigs/instance-types/Kconfig.r8i-flex.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_T1
+source "terraform/aws/kconfigs/instance-types/Kconfig.t1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_T2
+source "terraform/aws/kconfigs/instance-types/Kconfig.t2.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_T3
+source "terraform/aws/kconfigs/instance-types/Kconfig.t3.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_T3A
+source "terraform/aws/kconfigs/instance-types/Kconfig.t3a.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_T4G
+source "terraform/aws/kconfigs/instance-types/Kconfig.t4g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_TRN1
+source "terraform/aws/kconfigs/instance-types/Kconfig.trn1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_TRN1N
+source "terraform/aws/kconfigs/instance-types/Kconfig.trn1n.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U_3TB1
+source "terraform/aws/kconfigs/instance-types/Kconfig.u-3tb1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U_6TB1
+source "terraform/aws/kconfigs/instance-types/Kconfig.u-6tb1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U7I_12TB
+source "terraform/aws/kconfigs/instance-types/Kconfig.u7i-12tb.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U7I_6TB
+source "terraform/aws/kconfigs/instance-types/Kconfig.u7i-6tb.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U7I_8TB
+source "terraform/aws/kconfigs/instance-types/Kconfig.u7i-8tb.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U7IN_16TB
+source "terraform/aws/kconfigs/instance-types/Kconfig.u7in-16tb.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U7IN_24TB
+source "terraform/aws/kconfigs/instance-types/Kconfig.u7in-24tb.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_U7IN_32TB
+source "terraform/aws/kconfigs/instance-types/Kconfig.u7in-32tb.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_VT1
+source "terraform/aws/kconfigs/instance-types/Kconfig.vt1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_X1
+source "terraform/aws/kconfigs/instance-types/Kconfig.x1.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_X1E
+source "terraform/aws/kconfigs/instance-types/Kconfig.x1e.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_X2GD
+source "terraform/aws/kconfigs/instance-types/Kconfig.x2gd.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_X2IDN
+source "terraform/aws/kconfigs/instance-types/Kconfig.x2idn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_X2IEDN
+source "terraform/aws/kconfigs/instance-types/Kconfig.x2iedn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_X2IEZN
+source "terraform/aws/kconfigs/instance-types/Kconfig.x2iezn.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_X8G
+source "terraform/aws/kconfigs/instance-types/Kconfig.x8g.static"
+endif
+
+if TERRAFORM_AWS_INSTANCE_TYPE_Z1D
+source "terraform/aws/kconfigs/instance-types/Kconfig.z1d.static"
+endif
+
+# Final instance type configuration
+config TERRAFORM_AWS_INSTANCE_TYPE
+ string
+ output yaml
+ default TERRAFORM_AWS_A1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_A1
+ default TERRAFORM_AWS_C1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C1
+ default TERRAFORM_AWS_C3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C3
+ default TERRAFORM_AWS_C4_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C4
+ default TERRAFORM_AWS_C5_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C5
+ default TERRAFORM_AWS_C5A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C5A
+ default TERRAFORM_AWS_C5AD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C5AD
+ default TERRAFORM_AWS_C5D_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C5D
+ default TERRAFORM_AWS_C5N_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C5N
+ default TERRAFORM_AWS_C6A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C6A
+ default TERRAFORM_AWS_C6G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C6G
+ default TERRAFORM_AWS_C6GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C6GD
+ default TERRAFORM_AWS_C6GN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C6GN
+ default TERRAFORM_AWS_C6I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C6I
+ default TERRAFORM_AWS_C6ID_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C6ID
+ default TERRAFORM_AWS_C6IN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C6IN
+ default TERRAFORM_AWS_C7A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C7A
+ default TERRAFORM_AWS_C7G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C7G
+ default TERRAFORM_AWS_C7GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C7GD
+ default TERRAFORM_AWS_C7GN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C7GN
+ default TERRAFORM_AWS_C7I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C7I
+ default TERRAFORM_AWS_C7I_FLEX_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C7I_FLEX
+ default TERRAFORM_AWS_C8G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C8G
+ default TERRAFORM_AWS_C8GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C8GD
+ default TERRAFORM_AWS_C8GN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_C8GN
+ default TERRAFORM_AWS_D2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_D2
+ default TERRAFORM_AWS_D3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_D3
+ default TERRAFORM_AWS_D3EN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_D3EN
+ default TERRAFORM_AWS_DL1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_DL1
+ default TERRAFORM_AWS_F1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_F1
+ default TERRAFORM_AWS_F2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_F2
+ default TERRAFORM_AWS_G4AD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_G4AD
+ default TERRAFORM_AWS_G4DN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_G4DN
+ default TERRAFORM_AWS_G5_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_G5
+ default TERRAFORM_AWS_G5G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_G5G
+ default TERRAFORM_AWS_G6_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_G6
+ default TERRAFORM_AWS_G6E_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_G6E
+ default TERRAFORM_AWS_G6F_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_G6F
+ default TERRAFORM_AWS_GR6_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_GR6
+ default TERRAFORM_AWS_GR6F_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_GR6F
+ default TERRAFORM_AWS_H1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_H1
+ default TERRAFORM_AWS_HPC7G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_HPC7G
+ default TERRAFORM_AWS_I2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I2
+ default TERRAFORM_AWS_I3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I3
+ default TERRAFORM_AWS_I3EN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I3EN
+ default TERRAFORM_AWS_I4G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I4G
+ default TERRAFORM_AWS_I4I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I4I
+ default TERRAFORM_AWS_I7I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I7I
+ default TERRAFORM_AWS_I7IE_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I7IE
+ default TERRAFORM_AWS_I8G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I8G
+ default TERRAFORM_AWS_I8GE_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_I8GE
+ default TERRAFORM_AWS_IM4GN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_IM4GN
+ default TERRAFORM_AWS_INF1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_INF1
+ default TERRAFORM_AWS_INF2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_INF2
+ default TERRAFORM_AWS_IS4GEN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_IS4GEN
+ default TERRAFORM_AWS_M1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M1
+ default TERRAFORM_AWS_M2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M2
+ default TERRAFORM_AWS_M3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M3
+ default TERRAFORM_AWS_M4_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M4
+ default TERRAFORM_AWS_M5_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5
+ default TERRAFORM_AWS_M5A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5A
+ default TERRAFORM_AWS_M5AD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5AD
+ default TERRAFORM_AWS_M5D_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5D
+ default TERRAFORM_AWS_M5DN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5DN
+ default TERRAFORM_AWS_M5N_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5N
+ default TERRAFORM_AWS_M5ZN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M5ZN
+ default TERRAFORM_AWS_M6A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M6A
+ default TERRAFORM_AWS_M6G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M6G
+ default TERRAFORM_AWS_M6GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M6GD
+ default TERRAFORM_AWS_M6I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M6I
+ default TERRAFORM_AWS_M6ID_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M6ID
+ default TERRAFORM_AWS_M6IDN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M6IDN
+ default TERRAFORM_AWS_M6IN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M6IN
+ default TERRAFORM_AWS_M7A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M7A
+ default TERRAFORM_AWS_M7G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M7G
+ default TERRAFORM_AWS_M7GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M7GD
+ default TERRAFORM_AWS_M7I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M7I
+ default TERRAFORM_AWS_M7I_FLEX_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M7I_FLEX
+ default TERRAFORM_AWS_M8G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M8G
+ default TERRAFORM_AWS_M8GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M8GD
+ default TERRAFORM_AWS_M8I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M8I
+ default TERRAFORM_AWS_M8I_FLEX_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_M8I_FLEX
+ default TERRAFORM_AWS_MAC1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_MAC1
+ default TERRAFORM_AWS_MAC2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_MAC2
+ default TERRAFORM_AWS_MAC2_M1ULTRA_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M1ULTRA
+ default TERRAFORM_AWS_MAC2_M2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M2
+ default TERRAFORM_AWS_MAC2_M2PRO_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_MAC2_M2PRO
+ default TERRAFORM_AWS_P3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_P3
+ default TERRAFORM_AWS_P3DN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_P3DN
+ default TERRAFORM_AWS_P4D_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_P4D
+ default TERRAFORM_AWS_P4DE_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_P4DE
+ default TERRAFORM_AWS_P5_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_P5
+ default TERRAFORM_AWS_P5EN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_P5EN
+ default TERRAFORM_AWS_P6_B200_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_P6_B200
+ default TERRAFORM_AWS_R3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R3
+ default TERRAFORM_AWS_R4_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R4
+ default TERRAFORM_AWS_R5_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R5
+ default TERRAFORM_AWS_R5A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R5A
+ default TERRAFORM_AWS_R5AD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R5AD
+ default TERRAFORM_AWS_R5B_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R5B
+ default TERRAFORM_AWS_R5D_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R5D
+ default TERRAFORM_AWS_R5DN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R5DN
+ default TERRAFORM_AWS_R5N_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R5N
+ default TERRAFORM_AWS_R6A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R6A
+ default TERRAFORM_AWS_R6G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R6G
+ default TERRAFORM_AWS_R6GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R6GD
+ default TERRAFORM_AWS_R6I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R6I
+ default TERRAFORM_AWS_R6ID_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R6ID
+ default TERRAFORM_AWS_R6IDN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R6IDN
+ default TERRAFORM_AWS_R6IN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R6IN
+ default TERRAFORM_AWS_R7A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R7A
+ default TERRAFORM_AWS_R7G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R7G
+ default TERRAFORM_AWS_R7GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R7GD
+ default TERRAFORM_AWS_R7I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R7I
+ default TERRAFORM_AWS_R7IZ_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R7IZ
+ default TERRAFORM_AWS_R8G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R8G
+ default TERRAFORM_AWS_R8GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R8GD
+ default TERRAFORM_AWS_R8I_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R8I
+ default TERRAFORM_AWS_R8I_FLEX_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_R8I_FLEX
+ default TERRAFORM_AWS_T1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_T1
+ default TERRAFORM_AWS_T2_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_T2
+ default TERRAFORM_AWS_T3_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_T3
+ default TERRAFORM_AWS_T3A_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_T3A
+ default TERRAFORM_AWS_T4G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_T4G
+ default TERRAFORM_AWS_TRN1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_TRN1
+ default TERRAFORM_AWS_TRN1N_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_TRN1N
+ default TERRAFORM_AWS_U_3TB1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U_3TB1
+ default TERRAFORM_AWS_U_6TB1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U_6TB1
+ default TERRAFORM_AWS_U7I_12TB_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U7I_12TB
+ default TERRAFORM_AWS_U7I_6TB_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U7I_6TB
+ default TERRAFORM_AWS_U7I_8TB_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U7I_8TB
+ default TERRAFORM_AWS_U7IN_16TB_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U7IN_16TB
+ default TERRAFORM_AWS_U7IN_24TB_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U7IN_24TB
+ default TERRAFORM_AWS_U7IN_32TB_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_U7IN_32TB
+ default TERRAFORM_AWS_VT1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_VT1
+ default TERRAFORM_AWS_X1_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_X1
+ default TERRAFORM_AWS_X1E_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_X1E
+ default TERRAFORM_AWS_X2GD_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_X2GD
+ default TERRAFORM_AWS_X2IDN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_X2IDN
+ default TERRAFORM_AWS_X2IEDN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_X2IEDN
+ default TERRAFORM_AWS_X2IEZN_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_X2IEZN
+ default TERRAFORM_AWS_X8G_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_X8G
+ default TERRAFORM_AWS_Z1D_SIZE if TERRAFORM_AWS_INSTANCE_TYPE_Z1D
+ default "t3.micro"
+
diff --git a/terraform/aws/kconfigs/Kconfig.gpu-amis.static b/terraform/aws/kconfigs/Kconfig.gpu-amis.static
new file mode 100644
index 00000000..e4ea4576
--- /dev/null
+++ b/terraform/aws/kconfigs/Kconfig.gpu-amis.static
@@ -0,0 +1,79 @@
+# GPU-optimized AMIs (default - AWS CLI not available)
+
+# GPU AMI Override - only shown for GPU instances
+config TERRAFORM_AWS_USE_GPU_AMI
+ bool "Use GPU-optimized AMI instead of standard distribution"
+ depends on TERRAFORM_AWS_IS_GPU_INSTANCE
+ output yaml
+ default n
+ help
+ Enable this to use a GPU-optimized AMI with pre-installed NVIDIA drivers,
+ CUDA, and ML frameworks instead of the standard distribution AMI.
+ Note: AWS CLI is not available, showing default options.
+
+if TERRAFORM_AWS_USE_GPU_AMI
+
+choice
+ prompt "GPU-optimized AMI selection"
+ default TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+ depends on TERRAFORM_AWS_IS_GPU_INSTANCE
+ help
+ Select which GPU-optimized AMI to use for your GPU instance.
+
+config TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+ bool "AWS Deep Learning AMI (Ubuntu 22.04)"
+ help
+ Pre-configured with NVIDIA drivers, CUDA, and ML frameworks.
+
+config TERRAFORM_AWS_GPU_AMI_CUSTOM
+ bool "Custom GPU AMI"
+
+endchoice
+
+if TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+
+config TERRAFORM_AWS_GPU_AMI_NAME
+ string
+ output yaml
+ default "Deep Learning OSS Nvidia Driver AMI GPU PyTorch*Ubuntu 22.04*"
+
+config TERRAFORM_AWS_GPU_AMI_OWNER
+ string
+ output yaml
+ default "amazon"
+
+endif # TERRAFORM_AWS_GPU_AMI_DEEP_LEARNING
+
+if TERRAFORM_AWS_GPU_AMI_CUSTOM
+
+config TERRAFORM_AWS_GPU_AMI_ID
+ string "Custom GPU AMI ID"
+ output yaml
+ help
+ Specify the AMI ID for your custom GPU image.
+
+endif # TERRAFORM_AWS_GPU_AMI_CUSTOM
+
+endif # TERRAFORM_AWS_USE_GPU_AMI
+
+# GPU instance detection (static)
+config TERRAFORM_AWS_IS_GPU_INSTANCE
+ bool
+ output yaml
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G6E
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G6
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G5
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G5G
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G4DN
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_G4AD
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P5
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P5EN
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P4D
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P4DE
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P3
+ default y if TERRAFORM_AWS_INSTANCE_TYPE_P3DN
+ default n
+ help
+ Automatically detected based on selected instance type.
+ This indicates whether the selected instance has GPU support.
+
diff --git a/terraform/aws/kconfigs/Kconfig.location.static b/terraform/aws/kconfigs/Kconfig.location.static
new file mode 100644
index 00000000..840f5b3f
--- /dev/null
+++ b/terraform/aws/kconfigs/Kconfig.location.static
@@ -0,0 +1,124 @@
+# AWS regions (dynamically generated)
+
+choice
+ prompt "AWS region"
+ default TERRAFORM_AWS_REGION_USEAST1
+ help
+ Select the AWS region for your deployment.
+ Note: Not all instance types are available in all regions.
+
+# US Regions
+config TERRAFORM_AWS_REGION_US_EAST_1
+ bool "US East (N. Virginia)"
+ help
+ Region: US East (N. Virginia)
+
+config TERRAFORM_AWS_REGION_US_EAST_2
+ bool "US East (Ohio)"
+ help
+ Region: US East (Ohio)
+
+config TERRAFORM_AWS_REGION_US_WEST_1
+ bool "US West (N. California)"
+ help
+ Region: US West (N. California)
+
+config TERRAFORM_AWS_REGION_US_WEST_2
+ bool "US West (Oregon)"
+ help
+ Region: US West (Oregon)
+
+
+# Europe Regions
+config TERRAFORM_AWS_REGION_EU_CENTRAL_1
+ bool "Europe (Frankfurt)"
+ help
+ Region: Europe (Frankfurt)
+
+config TERRAFORM_AWS_REGION_EU_NORTH_1
+ bool "Europe (Stockholm)"
+ help
+ Region: Europe (Stockholm)
+
+config TERRAFORM_AWS_REGION_EU_WEST_1
+ bool "Europe (Ireland)"
+ help
+ Region: Europe (Ireland)
+
+config TERRAFORM_AWS_REGION_EU_WEST_2
+ bool "Europe (London)"
+ help
+ Region: Europe (London)
+
+config TERRAFORM_AWS_REGION_EU_WEST_3
+ bool "Europe (Paris)"
+ help
+ Region: Europe (Paris)
+
+
+# Asia Pacific Regions
+config TERRAFORM_AWS_REGION_AP_NORTHEAST_1
+ bool "Asia Pacific (Tokyo)"
+ help
+ Region: Asia Pacific (Tokyo)
+
+config TERRAFORM_AWS_REGION_AP_NORTHEAST_2
+ bool "Asia Pacific (Seoul)"
+ help
+ Region: Asia Pacific (Seoul)
+
+config TERRAFORM_AWS_REGION_AP_NORTHEAST_3
+ bool "Ap Northeast 3"
+ help
+ Region: Ap Northeast 3
+
+config TERRAFORM_AWS_REGION_AP_SOUTH_1
+ bool "Asia Pacific (Mumbai)"
+ help
+ Region: Asia Pacific (Mumbai)
+
+config TERRAFORM_AWS_REGION_AP_SOUTHEAST_1
+ bool "Asia Pacific (Singapore)"
+ help
+ Region: Asia Pacific (Singapore)
+
+config TERRAFORM_AWS_REGION_AP_SOUTHEAST_2
+ bool "Asia Pacific (Sydney)"
+ help
+ Region: Asia Pacific (Sydney)
+
+
+# Other Regions
+config TERRAFORM_AWS_REGION_CA_CENTRAL_1
+ bool "Canada (Central)"
+ help
+ Region: Canada (Central)
+
+config TERRAFORM_AWS_REGION_SA_EAST_1
+ bool "South America (São Paulo)"
+ help
+ Region: South America (São Paulo)
+
+
+endchoice
+
+config TERRAFORM_AWS_REGION
+ string
+ default "ap-south-1" if TERRAFORM_AWS_REGION_AP_SOUTH_1
+ default "eu-north-1" if TERRAFORM_AWS_REGION_EU_NORTH_1
+ default "eu-west-3" if TERRAFORM_AWS_REGION_EU_WEST_3
+ default "eu-west-2" if TERRAFORM_AWS_REGION_EU_WEST_2
+ default "eu-west-1" if TERRAFORM_AWS_REGION_EU_WEST_1
+ default "ap-northeast-3" if TERRAFORM_AWS_REGION_AP_NORTHEAST_3
+ default "ap-northeast-2" if TERRAFORM_AWS_REGION_AP_NORTHEAST_2
+ default "ap-northeast-1" if TERRAFORM_AWS_REGION_AP_NORTHEAST_1
+ default "ca-central-1" if TERRAFORM_AWS_REGION_CA_CENTRAL_1
+ default "sa-east-1" if TERRAFORM_AWS_REGION_SA_EAST_1
+ default "ap-southeast-1" if TERRAFORM_AWS_REGION_AP_SOUTHEAST_1
+ default "ap-southeast-2" if TERRAFORM_AWS_REGION_AP_SOUTHEAST_2
+ default "eu-central-1" if TERRAFORM_AWS_REGION_EU_CENTRAL_1
+ default "us-east-1" if TERRAFORM_AWS_REGION_US_EAST_1
+ default "us-east-2" if TERRAFORM_AWS_REGION_US_EAST_2
+ default "us-west-1" if TERRAFORM_AWS_REGION_US_WEST_1
+ default "us-west-2" if TERRAFORM_AWS_REGION_US_WEST_2
+ default "us-east-1"
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.a1.static b/terraform/aws/kconfigs/instance-types/Kconfig.a1.static
new file mode 100644
index 00000000..35c1bbf6
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.a1.static
@@ -0,0 +1,68 @@
+# AWS A1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for A1 family"
+ default TERRAFORM_AWS_INSTANCE_A1_MEDIUM
+ help
+ Select the specific instance size within the A1 family.
+
+config TERRAFORM_AWS_INSTANCE_A1_MEDIUM
+ bool "a1.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_A1_LARGE
+ bool "a1.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_A1_XLARGE
+ bool "a1.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_A1_2XLARGE
+ bool "a1.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_A1_METAL
+ bool "a1.metal"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_A1_4XLARGE
+ bool "a1.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_A1_SIZE
+ string
+ default "a1.medium" if TERRAFORM_AWS_INSTANCE_A1_MEDIUM
+ default "a1.large" if TERRAFORM_AWS_INSTANCE_A1_LARGE
+ default "a1.xlarge" if TERRAFORM_AWS_INSTANCE_A1_XLARGE
+ default "a1.2xlarge" if TERRAFORM_AWS_INSTANCE_A1_2XLARGE
+ default "a1.metal" if TERRAFORM_AWS_INSTANCE_A1_METAL
+ default "a1.4xlarge" if TERRAFORM_AWS_INSTANCE_A1_4XLARGE
+ default "a1.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c1.static b/terraform/aws/kconfigs/instance-types/Kconfig.c1.static
new file mode 100644
index 00000000..dee6309f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c1.static
@@ -0,0 +1,34 @@
+# AWS C1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C1 family"
+ default TERRAFORM_AWS_INSTANCE_C1_MEDIUM
+ help
+ Select the specific instance size within the C1 family.
+
+config TERRAFORM_AWS_INSTANCE_C1_MEDIUM
+ bool "c1.medium"
+ help
+ vCPUs: 2
+ Memory: 1.7 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 350 GB
+
+config TERRAFORM_AWS_INSTANCE_C1_XLARGE
+ bool "c1.xlarge"
+ help
+ vCPUs: 8
+ Memory: 7.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 1680 GB
+
+endchoice
+
+config TERRAFORM_AWS_C1_SIZE
+ string
+ default "c1.medium" if TERRAFORM_AWS_INSTANCE_C1_MEDIUM
+ default "c1.xlarge" if TERRAFORM_AWS_INSTANCE_C1_XLARGE
+ default "c1.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c3.static b/terraform/aws/kconfigs/instance-types/Kconfig.c3.static
new file mode 100644
index 00000000..fd1d8ab9
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c3.static
@@ -0,0 +1,64 @@
+# AWS C3 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C3 family"
+ default TERRAFORM_AWS_INSTANCE_C3_LARGE
+ help
+ Select the specific instance size within the C3 family.
+
+config TERRAFORM_AWS_INSTANCE_C3_LARGE
+ bool "c3.large"
+ help
+ vCPUs: 2
+ Memory: 3.8 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 32 GB
+
+config TERRAFORM_AWS_INSTANCE_C3_XLARGE
+ bool "c3.xlarge"
+ help
+ vCPUs: 4
+ Memory: 7.5 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 80 GB
+
+config TERRAFORM_AWS_INSTANCE_C3_2XLARGE
+ bool "c3.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 15.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 160 GB
+
+config TERRAFORM_AWS_INSTANCE_C3_4XLARGE
+ bool "c3.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 30.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 320 GB
+
+config TERRAFORM_AWS_INSTANCE_C3_8XLARGE
+ bool "c3.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 60.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 640 GB
+
+endchoice
+
+config TERRAFORM_AWS_C3_SIZE
+ string
+ default "c3.large" if TERRAFORM_AWS_INSTANCE_C3_LARGE
+ default "c3.xlarge" if TERRAFORM_AWS_INSTANCE_C3_XLARGE
+ default "c3.2xlarge" if TERRAFORM_AWS_INSTANCE_C3_2XLARGE
+ default "c3.4xlarge" if TERRAFORM_AWS_INSTANCE_C3_4XLARGE
+ default "c3.8xlarge" if TERRAFORM_AWS_INSTANCE_C3_8XLARGE
+ default "c3.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c4.static b/terraform/aws/kconfigs/instance-types/Kconfig.c4.static
new file mode 100644
index 00000000..850b0bd8
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c4.static
@@ -0,0 +1,59 @@
+# AWS C4 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C4 family"
+ default TERRAFORM_AWS_INSTANCE_C4_LARGE
+ help
+ Select the specific instance size within the C4 family.
+
+config TERRAFORM_AWS_INSTANCE_C4_LARGE
+ bool "c4.large"
+ help
+ vCPUs: 2
+ Memory: 3.8 GB
+ Network: Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C4_XLARGE
+ bool "c4.xlarge"
+ help
+ vCPUs: 4
+ Memory: 7.5 GB
+ Network: High
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C4_2XLARGE
+ bool "c4.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 15.0 GB
+ Network: High
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C4_4XLARGE
+ bool "c4.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 30.0 GB
+ Network: High
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C4_8XLARGE
+ bool "c4.8xlarge"
+ help
+ vCPUs: 36
+ Memory: 60.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C4_SIZE
+ string
+ default "c4.large" if TERRAFORM_AWS_INSTANCE_C4_LARGE
+ default "c4.xlarge" if TERRAFORM_AWS_INSTANCE_C4_XLARGE
+ default "c4.2xlarge" if TERRAFORM_AWS_INSTANCE_C4_2XLARGE
+ default "c4.4xlarge" if TERRAFORM_AWS_INSTANCE_C4_4XLARGE
+ default "c4.8xlarge" if TERRAFORM_AWS_INSTANCE_C4_8XLARGE
+ default "c4.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c5.static b/terraform/aws/kconfigs/instance-types/Kconfig.c5.static
new file mode 100644
index 00000000..64217234
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c5.static
@@ -0,0 +1,95 @@
+# AWS C5 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C5 family"
+ default TERRAFORM_AWS_INSTANCE_C5_LARGE
+ help
+ Select the specific instance size within the C5 family.
+
+config TERRAFORM_AWS_INSTANCE_C5_LARGE
+ bool "c5.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.085/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_XLARGE
+ bool "c5.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.170/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_2XLARGE
+ bool "c5.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.340/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_4XLARGE
+ bool "c5.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.680/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_9XLARGE
+ bool "c5.9xlarge"
+ help
+ vCPUs: 36
+ Memory: 72.0 GB
+ Network: 12 Gigabit
+ Price: $1.530/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_12XLARGE
+ bool "c5.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 12 Gigabit
+ Price: $2.040/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_18XLARGE
+ bool "c5.18xlarge"
+ help
+ vCPUs: 72
+ Memory: 144.0 GB
+ Network: 25 Gigabit
+ Price: $3.060/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_24XLARGE
+ bool "c5.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 25 Gigabit
+ Price: $4.080/hour
+
+config TERRAFORM_AWS_INSTANCE_C5_METAL
+ bool "c5.metal"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C5_SIZE
+ string
+ default "c5.large" if TERRAFORM_AWS_INSTANCE_C5_LARGE
+ default "c5.xlarge" if TERRAFORM_AWS_INSTANCE_C5_XLARGE
+ default "c5.2xlarge" if TERRAFORM_AWS_INSTANCE_C5_2XLARGE
+ default "c5.4xlarge" if TERRAFORM_AWS_INSTANCE_C5_4XLARGE
+ default "c5.9xlarge" if TERRAFORM_AWS_INSTANCE_C5_9XLARGE
+ default "c5.12xlarge" if TERRAFORM_AWS_INSTANCE_C5_12XLARGE
+ default "c5.18xlarge" if TERRAFORM_AWS_INSTANCE_C5_18XLARGE
+ default "c5.24xlarge" if TERRAFORM_AWS_INSTANCE_C5_24XLARGE
+ default "c5.metal" if TERRAFORM_AWS_INSTANCE_C5_METAL
+ default "c5.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c5a.static b/terraform/aws/kconfigs/instance-types/Kconfig.c5a.static
new file mode 100644
index 00000000..bbcb8f7b
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c5a.static
@@ -0,0 +1,86 @@
+# AWS C5A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C5A family"
+ default TERRAFORM_AWS_INSTANCE_C5A_LARGE
+ help
+ Select the specific instance size within the C5A family.
+
+config TERRAFORM_AWS_INSTANCE_C5A_LARGE
+ bool "c5a.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5A_XLARGE
+ bool "c5a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5A_2XLARGE
+ bool "c5a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5A_4XLARGE
+ bool "c5a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5A_8XLARGE
+ bool "c5a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5A_12XLARGE
+ bool "c5a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5A_16XLARGE
+ bool "c5a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5A_24XLARGE
+ bool "c5a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C5A_SIZE
+ string
+ default "c5a.large" if TERRAFORM_AWS_INSTANCE_C5A_LARGE
+ default "c5a.xlarge" if TERRAFORM_AWS_INSTANCE_C5A_XLARGE
+ default "c5a.2xlarge" if TERRAFORM_AWS_INSTANCE_C5A_2XLARGE
+ default "c5a.4xlarge" if TERRAFORM_AWS_INSTANCE_C5A_4XLARGE
+ default "c5a.8xlarge" if TERRAFORM_AWS_INSTANCE_C5A_8XLARGE
+ default "c5a.12xlarge" if TERRAFORM_AWS_INSTANCE_C5A_12XLARGE
+ default "c5a.16xlarge" if TERRAFORM_AWS_INSTANCE_C5A_16XLARGE
+ default "c5a.24xlarge" if TERRAFORM_AWS_INSTANCE_C5A_24XLARGE
+ default "c5a.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c5ad.static b/terraform/aws/kconfigs/instance-types/Kconfig.c5ad.static
new file mode 100644
index 00000000..3c3f1ffa
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c5ad.static
@@ -0,0 +1,94 @@
+# AWS C5AD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C5AD family"
+ default TERRAFORM_AWS_INSTANCE_C5AD_LARGE
+ help
+ Select the specific instance size within the C5AD family.
+
+config TERRAFORM_AWS_INSTANCE_C5AD_LARGE
+ bool "c5ad.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_C5AD_XLARGE
+ bool "c5ad.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_C5AD_2XLARGE
+ bool "c5ad.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_C5AD_4XLARGE
+ bool "c5ad.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_C5AD_8XLARGE
+ bool "c5ad.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_C5AD_12XLARGE
+ bool "c5ad.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_C5AD_16XLARGE
+ bool "c5ad.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+config TERRAFORM_AWS_INSTANCE_C5AD_24XLARGE
+ bool "c5ad.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_C5AD_SIZE
+ string
+ default "c5ad.large" if TERRAFORM_AWS_INSTANCE_C5AD_LARGE
+ default "c5ad.xlarge" if TERRAFORM_AWS_INSTANCE_C5AD_XLARGE
+ default "c5ad.2xlarge" if TERRAFORM_AWS_INSTANCE_C5AD_2XLARGE
+ default "c5ad.4xlarge" if TERRAFORM_AWS_INSTANCE_C5AD_4XLARGE
+ default "c5ad.8xlarge" if TERRAFORM_AWS_INSTANCE_C5AD_8XLARGE
+ default "c5ad.12xlarge" if TERRAFORM_AWS_INSTANCE_C5AD_12XLARGE
+ default "c5ad.16xlarge" if TERRAFORM_AWS_INSTANCE_C5AD_16XLARGE
+ default "c5ad.24xlarge" if TERRAFORM_AWS_INSTANCE_C5AD_24XLARGE
+ default "c5ad.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c5d.static b/terraform/aws/kconfigs/instance-types/Kconfig.c5d.static
new file mode 100644
index 00000000..93f3e5b5
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c5d.static
@@ -0,0 +1,104 @@
+# AWS C5D instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C5D family"
+ default TERRAFORM_AWS_INSTANCE_C5D_LARGE
+ help
+ Select the specific instance size within the C5D family.
+
+config TERRAFORM_AWS_INSTANCE_C5D_LARGE
+ bool "c5d.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 50 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_XLARGE
+ bool "c5d.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 100 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_2XLARGE
+ bool "c5d.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 200 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_4XLARGE
+ bool "c5d.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 400 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_9XLARGE
+ bool "c5d.9xlarge"
+ help
+ vCPUs: 36
+ Memory: 72.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_12XLARGE
+ bool "c5d.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_18XLARGE
+ bool "c5d.18xlarge"
+ help
+ vCPUs: 72
+ Memory: 144.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_24XLARGE
+ bool "c5d.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+config TERRAFORM_AWS_INSTANCE_C5D_METAL
+ bool "c5d.metal"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+endchoice
+
+config TERRAFORM_AWS_C5D_SIZE
+ string
+ default "c5d.large" if TERRAFORM_AWS_INSTANCE_C5D_LARGE
+ default "c5d.xlarge" if TERRAFORM_AWS_INSTANCE_C5D_XLARGE
+ default "c5d.2xlarge" if TERRAFORM_AWS_INSTANCE_C5D_2XLARGE
+ default "c5d.4xlarge" if TERRAFORM_AWS_INSTANCE_C5D_4XLARGE
+ default "c5d.9xlarge" if TERRAFORM_AWS_INSTANCE_C5D_9XLARGE
+ default "c5d.12xlarge" if TERRAFORM_AWS_INSTANCE_C5D_12XLARGE
+ default "c5d.18xlarge" if TERRAFORM_AWS_INSTANCE_C5D_18XLARGE
+ default "c5d.24xlarge" if TERRAFORM_AWS_INSTANCE_C5D_24XLARGE
+ default "c5d.metal" if TERRAFORM_AWS_INSTANCE_C5D_METAL
+ default "c5d.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c5n.static b/terraform/aws/kconfigs/instance-types/Kconfig.c5n.static
new file mode 100644
index 00000000..afce27b3
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c5n.static
@@ -0,0 +1,77 @@
+# AWS C5N instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C5N family"
+ default TERRAFORM_AWS_INSTANCE_C5N_LARGE
+ help
+ Select the specific instance size within the C5N family.
+
+config TERRAFORM_AWS_INSTANCE_C5N_LARGE
+ bool "c5n.large"
+ help
+ vCPUs: 2
+ Memory: 5.2 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5N_XLARGE
+ bool "c5n.xlarge"
+ help
+ vCPUs: 4
+ Memory: 10.5 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5N_2XLARGE
+ bool "c5n.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 21.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5N_4XLARGE
+ bool "c5n.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 42.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5N_9XLARGE
+ bool "c5n.9xlarge"
+ help
+ vCPUs: 36
+ Memory: 96.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5N_18XLARGE
+ bool "c5n.18xlarge"
+ help
+ vCPUs: 72
+ Memory: 192.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C5N_METAL
+ bool "c5n.metal"
+ help
+ vCPUs: 72
+ Memory: 192.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C5N_SIZE
+ string
+ default "c5n.large" if TERRAFORM_AWS_INSTANCE_C5N_LARGE
+ default "c5n.xlarge" if TERRAFORM_AWS_INSTANCE_C5N_XLARGE
+ default "c5n.2xlarge" if TERRAFORM_AWS_INSTANCE_C5N_2XLARGE
+ default "c5n.4xlarge" if TERRAFORM_AWS_INSTANCE_C5N_4XLARGE
+ default "c5n.9xlarge" if TERRAFORM_AWS_INSTANCE_C5N_9XLARGE
+ default "c5n.18xlarge" if TERRAFORM_AWS_INSTANCE_C5N_18XLARGE
+ default "c5n.metal" if TERRAFORM_AWS_INSTANCE_C5N_METAL
+ default "c5n.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c6a.static b/terraform/aws/kconfigs/instance-types/Kconfig.c6a.static
new file mode 100644
index 00000000..c17c74d2
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c6a.static
@@ -0,0 +1,113 @@
+# AWS C6A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C6A family"
+ default TERRAFORM_AWS_INSTANCE_C6A_LARGE
+ help
+ Select the specific instance size within the C6A family.
+
+config TERRAFORM_AWS_INSTANCE_C6A_LARGE
+ bool "c6a.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_XLARGE
+ bool "c6a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_2XLARGE
+ bool "c6a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_4XLARGE
+ bool "c6a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_8XLARGE
+ bool "c6a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_12XLARGE
+ bool "c6a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_16XLARGE
+ bool "c6a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_24XLARGE
+ bool "c6a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_32XLARGE
+ bool "c6a.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_48XLARGE
+ bool "c6a.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6A_METAL
+ bool "c6a.metal"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C6A_SIZE
+ string
+ default "c6a.large" if TERRAFORM_AWS_INSTANCE_C6A_LARGE
+ default "c6a.xlarge" if TERRAFORM_AWS_INSTANCE_C6A_XLARGE
+ default "c6a.2xlarge" if TERRAFORM_AWS_INSTANCE_C6A_2XLARGE
+ default "c6a.4xlarge" if TERRAFORM_AWS_INSTANCE_C6A_4XLARGE
+ default "c6a.8xlarge" if TERRAFORM_AWS_INSTANCE_C6A_8XLARGE
+ default "c6a.12xlarge" if TERRAFORM_AWS_INSTANCE_C6A_12XLARGE
+ default "c6a.16xlarge" if TERRAFORM_AWS_INSTANCE_C6A_16XLARGE
+ default "c6a.24xlarge" if TERRAFORM_AWS_INSTANCE_C6A_24XLARGE
+ default "c6a.32xlarge" if TERRAFORM_AWS_INSTANCE_C6A_32XLARGE
+ default "c6a.48xlarge" if TERRAFORM_AWS_INSTANCE_C6A_48XLARGE
+ default "c6a.metal" if TERRAFORM_AWS_INSTANCE_C6A_METAL
+ default "c6a.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c6g.static b/terraform/aws/kconfigs/instance-types/Kconfig.c6g.static
new file mode 100644
index 00000000..b2050d36
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c6g.static
@@ -0,0 +1,95 @@
+# AWS C6G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C6G family"
+ default TERRAFORM_AWS_INSTANCE_C6G_MEDIUM
+ help
+ Select the specific instance size within the C6G family.
+
+config TERRAFORM_AWS_INSTANCE_C6G_MEDIUM
+ bool "c6g.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_LARGE
+ bool "c6g.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_XLARGE
+ bool "c6g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_2XLARGE
+ bool "c6g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_4XLARGE
+ bool "c6g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_8XLARGE
+ bool "c6g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_12XLARGE
+ bool "c6g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_16XLARGE
+ bool "c6g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6G_METAL
+ bool "c6g.metal"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C6G_SIZE
+ string
+ default "c6g.medium" if TERRAFORM_AWS_INSTANCE_C6G_MEDIUM
+ default "c6g.large" if TERRAFORM_AWS_INSTANCE_C6G_LARGE
+ default "c6g.xlarge" if TERRAFORM_AWS_INSTANCE_C6G_XLARGE
+ default "c6g.2xlarge" if TERRAFORM_AWS_INSTANCE_C6G_2XLARGE
+ default "c6g.4xlarge" if TERRAFORM_AWS_INSTANCE_C6G_4XLARGE
+ default "c6g.8xlarge" if TERRAFORM_AWS_INSTANCE_C6G_8XLARGE
+ default "c6g.12xlarge" if TERRAFORM_AWS_INSTANCE_C6G_12XLARGE
+ default "c6g.16xlarge" if TERRAFORM_AWS_INSTANCE_C6G_16XLARGE
+ default "c6g.metal" if TERRAFORM_AWS_INSTANCE_C6G_METAL
+ default "c6g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c6gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.c6gd.static
new file mode 100644
index 00000000..74de024c
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c6gd.static
@@ -0,0 +1,104 @@
+# AWS C6GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C6GD family"
+ default TERRAFORM_AWS_INSTANCE_C6GD_MEDIUM
+ help
+ Select the specific instance size within the C6GD family.
+
+config TERRAFORM_AWS_INSTANCE_C6GD_MEDIUM
+ bool "c6gd.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_LARGE
+ bool "c6gd.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_XLARGE
+ bool "c6gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_2XLARGE
+ bool "c6gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_4XLARGE
+ bool "c6gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_8XLARGE
+ bool "c6gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_12XLARGE
+ bool "c6gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_METAL
+ bool "c6gd.metal"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_C6GD_16XLARGE
+ bool "c6gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_C6GD_SIZE
+ string
+ default "c6gd.medium" if TERRAFORM_AWS_INSTANCE_C6GD_MEDIUM
+ default "c6gd.large" if TERRAFORM_AWS_INSTANCE_C6GD_LARGE
+ default "c6gd.xlarge" if TERRAFORM_AWS_INSTANCE_C6GD_XLARGE
+ default "c6gd.2xlarge" if TERRAFORM_AWS_INSTANCE_C6GD_2XLARGE
+ default "c6gd.4xlarge" if TERRAFORM_AWS_INSTANCE_C6GD_4XLARGE
+ default "c6gd.8xlarge" if TERRAFORM_AWS_INSTANCE_C6GD_8XLARGE
+ default "c6gd.12xlarge" if TERRAFORM_AWS_INSTANCE_C6GD_12XLARGE
+ default "c6gd.metal" if TERRAFORM_AWS_INSTANCE_C6GD_METAL
+ default "c6gd.16xlarge" if TERRAFORM_AWS_INSTANCE_C6GD_16XLARGE
+ default "c6gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c6gn.static b/terraform/aws/kconfigs/instance-types/Kconfig.c6gn.static
new file mode 100644
index 00000000..9fdd7a77
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c6gn.static
@@ -0,0 +1,86 @@
+# AWS C6GN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C6GN family"
+ default TERRAFORM_AWS_INSTANCE_C6GN_MEDIUM
+ help
+ Select the specific instance size within the C6GN family.
+
+config TERRAFORM_AWS_INSTANCE_C6GN_MEDIUM
+ bool "c6gn.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 16 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6GN_LARGE
+ bool "c6gn.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6GN_XLARGE
+ bool "c6gn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6GN_2XLARGE
+ bool "c6gn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6GN_4XLARGE
+ bool "c6gn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6GN_8XLARGE
+ bool "c6gn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6GN_12XLARGE
+ bool "c6gn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6GN_16XLARGE
+ bool "c6gn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C6GN_SIZE
+ string
+ default "c6gn.medium" if TERRAFORM_AWS_INSTANCE_C6GN_MEDIUM
+ default "c6gn.large" if TERRAFORM_AWS_INSTANCE_C6GN_LARGE
+ default "c6gn.xlarge" if TERRAFORM_AWS_INSTANCE_C6GN_XLARGE
+ default "c6gn.2xlarge" if TERRAFORM_AWS_INSTANCE_C6GN_2XLARGE
+ default "c6gn.4xlarge" if TERRAFORM_AWS_INSTANCE_C6GN_4XLARGE
+ default "c6gn.8xlarge" if TERRAFORM_AWS_INSTANCE_C6GN_8XLARGE
+ default "c6gn.12xlarge" if TERRAFORM_AWS_INSTANCE_C6GN_12XLARGE
+ default "c6gn.16xlarge" if TERRAFORM_AWS_INSTANCE_C6GN_16XLARGE
+ default "c6gn.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c6i.static b/terraform/aws/kconfigs/instance-types/Kconfig.c6i.static
new file mode 100644
index 00000000..46dcc08d
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c6i.static
@@ -0,0 +1,104 @@
+# AWS C6I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C6I family"
+ default TERRAFORM_AWS_INSTANCE_C6I_LARGE
+ help
+ Select the specific instance size within the C6I family.
+
+config TERRAFORM_AWS_INSTANCE_C6I_LARGE
+ bool "c6i.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_XLARGE
+ bool "c6i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_2XLARGE
+ bool "c6i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_4XLARGE
+ bool "c6i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_8XLARGE
+ bool "c6i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_12XLARGE
+ bool "c6i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_16XLARGE
+ bool "c6i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_24XLARGE
+ bool "c6i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_32XLARGE
+ bool "c6i.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6I_METAL
+ bool "c6i.metal"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C6I_SIZE
+ string
+ default "c6i.large" if TERRAFORM_AWS_INSTANCE_C6I_LARGE
+ default "c6i.xlarge" if TERRAFORM_AWS_INSTANCE_C6I_XLARGE
+ default "c6i.2xlarge" if TERRAFORM_AWS_INSTANCE_C6I_2XLARGE
+ default "c6i.4xlarge" if TERRAFORM_AWS_INSTANCE_C6I_4XLARGE
+ default "c6i.8xlarge" if TERRAFORM_AWS_INSTANCE_C6I_8XLARGE
+ default "c6i.12xlarge" if TERRAFORM_AWS_INSTANCE_C6I_12XLARGE
+ default "c6i.16xlarge" if TERRAFORM_AWS_INSTANCE_C6I_16XLARGE
+ default "c6i.24xlarge" if TERRAFORM_AWS_INSTANCE_C6I_24XLARGE
+ default "c6i.32xlarge" if TERRAFORM_AWS_INSTANCE_C6I_32XLARGE
+ default "c6i.metal" if TERRAFORM_AWS_INSTANCE_C6I_METAL
+ default "c6i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c6id.static b/terraform/aws/kconfigs/instance-types/Kconfig.c6id.static
new file mode 100644
index 00000000..8ad41ca4
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c6id.static
@@ -0,0 +1,114 @@
+# AWS C6ID instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C6ID family"
+ default TERRAFORM_AWS_INSTANCE_C6ID_LARGE
+ help
+ Select the specific instance size within the C6ID family.
+
+config TERRAFORM_AWS_INSTANCE_C6ID_LARGE
+ bool "c6id.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_XLARGE
+ bool "c6id.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_2XLARGE
+ bool "c6id.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_4XLARGE
+ bool "c6id.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_8XLARGE
+ bool "c6id.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_12XLARGE
+ bool "c6id.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_16XLARGE
+ bool "c6id.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_24XLARGE
+ bool "c6id.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_32XLARGE
+ bool "c6id.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+config TERRAFORM_AWS_INSTANCE_C6ID_METAL
+ bool "c6id.metal"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_C6ID_SIZE
+ string
+ default "c6id.large" if TERRAFORM_AWS_INSTANCE_C6ID_LARGE
+ default "c6id.xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_XLARGE
+ default "c6id.2xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_2XLARGE
+ default "c6id.4xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_4XLARGE
+ default "c6id.8xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_8XLARGE
+ default "c6id.12xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_12XLARGE
+ default "c6id.16xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_16XLARGE
+ default "c6id.24xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_24XLARGE
+ default "c6id.32xlarge" if TERRAFORM_AWS_INSTANCE_C6ID_32XLARGE
+ default "c6id.metal" if TERRAFORM_AWS_INSTANCE_C6ID_METAL
+ default "c6id.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c6in.static b/terraform/aws/kconfigs/instance-types/Kconfig.c6in.static
new file mode 100644
index 00000000..9b2c976e
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c6in.static
@@ -0,0 +1,104 @@
+# AWS C6IN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C6IN family"
+ default TERRAFORM_AWS_INSTANCE_C6IN_LARGE
+ help
+ Select the specific instance size within the C6IN family.
+
+config TERRAFORM_AWS_INSTANCE_C6IN_LARGE
+ bool "c6in.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_XLARGE
+ bool "c6in.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_2XLARGE
+ bool "c6in.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_4XLARGE
+ bool "c6in.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_8XLARGE
+ bool "c6in.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_12XLARGE
+ bool "c6in.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_16XLARGE
+ bool "c6in.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_24XLARGE
+ bool "c6in.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_32XLARGE
+ bool "c6in.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C6IN_METAL
+ bool "c6in.metal"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C6IN_SIZE
+ string
+ default "c6in.large" if TERRAFORM_AWS_INSTANCE_C6IN_LARGE
+ default "c6in.xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_XLARGE
+ default "c6in.2xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_2XLARGE
+ default "c6in.4xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_4XLARGE
+ default "c6in.8xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_8XLARGE
+ default "c6in.12xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_12XLARGE
+ default "c6in.16xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_16XLARGE
+ default "c6in.24xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_24XLARGE
+ default "c6in.32xlarge" if TERRAFORM_AWS_INSTANCE_C6IN_32XLARGE
+ default "c6in.metal" if TERRAFORM_AWS_INSTANCE_C6IN_METAL
+ default "c6in.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c7a.static b/terraform/aws/kconfigs/instance-types/Kconfig.c7a.static
new file mode 100644
index 00000000..6125da89
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c7a.static
@@ -0,0 +1,122 @@
+# AWS C7A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C7A family"
+ default TERRAFORM_AWS_INSTANCE_C7A_MEDIUM
+ help
+ Select the specific instance size within the C7A family.
+
+config TERRAFORM_AWS_INSTANCE_C7A_MEDIUM
+ bool "c7a.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.039/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_LARGE
+ bool "c7a.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.077/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_XLARGE
+ bool "c7a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.155/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_2XLARGE
+ bool "c7a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.310/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_4XLARGE
+ bool "c7a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.619/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_8XLARGE
+ bool "c7a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12.5 Gigabit
+ Price: $1.238/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_12XLARGE
+ bool "c7a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 18.75 Gigabit
+ Price: $1.858/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_16XLARGE
+ bool "c7a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: $2.477/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_24XLARGE
+ bool "c7a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 37.5 Gigabit
+ Price: $3.715/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_32XLARGE
+ bool "c7a.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: $4.954/hour
+
+config TERRAFORM_AWS_INSTANCE_C7A_METAL_48XL
+ bool "c7a.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7A_48XLARGE
+ bool "c7a.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: $7.430/hour
+
+endchoice
+
+config TERRAFORM_AWS_C7A_SIZE
+ string
+ default "c7a.medium" if TERRAFORM_AWS_INSTANCE_C7A_MEDIUM
+ default "c7a.large" if TERRAFORM_AWS_INSTANCE_C7A_LARGE
+ default "c7a.xlarge" if TERRAFORM_AWS_INSTANCE_C7A_XLARGE
+ default "c7a.2xlarge" if TERRAFORM_AWS_INSTANCE_C7A_2XLARGE
+ default "c7a.4xlarge" if TERRAFORM_AWS_INSTANCE_C7A_4XLARGE
+ default "c7a.8xlarge" if TERRAFORM_AWS_INSTANCE_C7A_8XLARGE
+ default "c7a.12xlarge" if TERRAFORM_AWS_INSTANCE_C7A_12XLARGE
+ default "c7a.16xlarge" if TERRAFORM_AWS_INSTANCE_C7A_16XLARGE
+ default "c7a.24xlarge" if TERRAFORM_AWS_INSTANCE_C7A_24XLARGE
+ default "c7a.32xlarge" if TERRAFORM_AWS_INSTANCE_C7A_32XLARGE
+ default "c7a.metal-48xl" if TERRAFORM_AWS_INSTANCE_C7A_METAL_48XL
+ default "c7a.48xlarge" if TERRAFORM_AWS_INSTANCE_C7A_48XLARGE
+ default "c7a.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c7g.static b/terraform/aws/kconfigs/instance-types/Kconfig.c7g.static
new file mode 100644
index 00000000..2510db35
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c7g.static
@@ -0,0 +1,95 @@
+# AWS C7G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C7G family"
+ default TERRAFORM_AWS_INSTANCE_C7G_MEDIUM
+ help
+ Select the specific instance size within the C7G family.
+
+config TERRAFORM_AWS_INSTANCE_C7G_MEDIUM
+ bool "c7g.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_LARGE
+ bool "c7g.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_XLARGE
+ bool "c7g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_2XLARGE
+ bool "c7g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_4XLARGE
+ bool "c7g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_8XLARGE
+ bool "c7g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_12XLARGE
+ bool "c7g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_16XLARGE
+ bool "c7g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7G_METAL
+ bool "c7g.metal"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C7G_SIZE
+ string
+ default "c7g.medium" if TERRAFORM_AWS_INSTANCE_C7G_MEDIUM
+ default "c7g.large" if TERRAFORM_AWS_INSTANCE_C7G_LARGE
+ default "c7g.xlarge" if TERRAFORM_AWS_INSTANCE_C7G_XLARGE
+ default "c7g.2xlarge" if TERRAFORM_AWS_INSTANCE_C7G_2XLARGE
+ default "c7g.4xlarge" if TERRAFORM_AWS_INSTANCE_C7G_4XLARGE
+ default "c7g.8xlarge" if TERRAFORM_AWS_INSTANCE_C7G_8XLARGE
+ default "c7g.12xlarge" if TERRAFORM_AWS_INSTANCE_C7G_12XLARGE
+ default "c7g.16xlarge" if TERRAFORM_AWS_INSTANCE_C7G_16XLARGE
+ default "c7g.metal" if TERRAFORM_AWS_INSTANCE_C7G_METAL
+ default "c7g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c7gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.c7gd.static
new file mode 100644
index 00000000..adba400a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c7gd.static
@@ -0,0 +1,104 @@
+# AWS C7GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C7GD family"
+ default TERRAFORM_AWS_INSTANCE_C7GD_MEDIUM
+ help
+ Select the specific instance size within the C7GD family.
+
+config TERRAFORM_AWS_INSTANCE_C7GD_MEDIUM
+ bool "c7gd.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_LARGE
+ bool "c7gd.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_XLARGE
+ bool "c7gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_2XLARGE
+ bool "c7gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_4XLARGE
+ bool "c7gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_8XLARGE
+ bool "c7gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_12XLARGE
+ bool "c7gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_16XLARGE
+ bool "c7gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_C7GD_METAL
+ bool "c7gd.metal"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_C7GD_SIZE
+ string
+ default "c7gd.medium" if TERRAFORM_AWS_INSTANCE_C7GD_MEDIUM
+ default "c7gd.large" if TERRAFORM_AWS_INSTANCE_C7GD_LARGE
+ default "c7gd.xlarge" if TERRAFORM_AWS_INSTANCE_C7GD_XLARGE
+ default "c7gd.2xlarge" if TERRAFORM_AWS_INSTANCE_C7GD_2XLARGE
+ default "c7gd.4xlarge" if TERRAFORM_AWS_INSTANCE_C7GD_4XLARGE
+ default "c7gd.8xlarge" if TERRAFORM_AWS_INSTANCE_C7GD_8XLARGE
+ default "c7gd.12xlarge" if TERRAFORM_AWS_INSTANCE_C7GD_12XLARGE
+ default "c7gd.16xlarge" if TERRAFORM_AWS_INSTANCE_C7GD_16XLARGE
+ default "c7gd.metal" if TERRAFORM_AWS_INSTANCE_C7GD_METAL
+ default "c7gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c7gn.static b/terraform/aws/kconfigs/instance-types/Kconfig.c7gn.static
new file mode 100644
index 00000000..48605f5c
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c7gn.static
@@ -0,0 +1,95 @@
+# AWS C7GN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C7GN family"
+ default TERRAFORM_AWS_INSTANCE_C7GN_MEDIUM
+ help
+ Select the specific instance size within the C7GN family.
+
+config TERRAFORM_AWS_INSTANCE_C7GN_MEDIUM
+ bool "c7gn.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_LARGE
+ bool "c7gn.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_XLARGE
+ bool "c7gn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_2XLARGE
+ bool "c7gn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_4XLARGE
+ bool "c7gn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_8XLARGE
+ bool "c7gn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_12XLARGE
+ bool "c7gn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_16XLARGE
+ bool "c7gn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7GN_METAL
+ bool "c7gn.metal"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C7GN_SIZE
+ string
+ default "c7gn.medium" if TERRAFORM_AWS_INSTANCE_C7GN_MEDIUM
+ default "c7gn.large" if TERRAFORM_AWS_INSTANCE_C7GN_LARGE
+ default "c7gn.xlarge" if TERRAFORM_AWS_INSTANCE_C7GN_XLARGE
+ default "c7gn.2xlarge" if TERRAFORM_AWS_INSTANCE_C7GN_2XLARGE
+ default "c7gn.4xlarge" if TERRAFORM_AWS_INSTANCE_C7GN_4XLARGE
+ default "c7gn.8xlarge" if TERRAFORM_AWS_INSTANCE_C7GN_8XLARGE
+ default "c7gn.12xlarge" if TERRAFORM_AWS_INSTANCE_C7GN_12XLARGE
+ default "c7gn.16xlarge" if TERRAFORM_AWS_INSTANCE_C7GN_16XLARGE
+ default "c7gn.metal" if TERRAFORM_AWS_INSTANCE_C7GN_METAL
+ default "c7gn.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c7i-flex.static b/terraform/aws/kconfigs/instance-types/Kconfig.c7i-flex.static
new file mode 100644
index 00000000..189d5984
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c7i-flex.static
@@ -0,0 +1,77 @@
+# AWS C7I-FLEX instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C7I-FLEX family"
+ default TERRAFORM_AWS_INSTANCE_C7I_FLEX_LARGE
+ help
+ Select the specific instance size within the C7I-FLEX family.
+
+config TERRAFORM_AWS_INSTANCE_C7I_FLEX_LARGE
+ bool "c7i-flex.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_FLEX_XLARGE
+ bool "c7i-flex.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_FLEX_2XLARGE
+ bool "c7i-flex.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_FLEX_4XLARGE
+ bool "c7i-flex.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_FLEX_8XLARGE
+ bool "c7i-flex.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_FLEX_12XLARGE
+ bool "c7i-flex.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: Up to 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_FLEX_16XLARGE
+ bool "c7i-flex.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C7I_FLEX_SIZE
+ string
+ default "c7i-flex.large" if TERRAFORM_AWS_INSTANCE_C7I_FLEX_LARGE
+ default "c7i-flex.xlarge" if TERRAFORM_AWS_INSTANCE_C7I_FLEX_XLARGE
+ default "c7i-flex.2xlarge" if TERRAFORM_AWS_INSTANCE_C7I_FLEX_2XLARGE
+ default "c7i-flex.4xlarge" if TERRAFORM_AWS_INSTANCE_C7I_FLEX_4XLARGE
+ default "c7i-flex.8xlarge" if TERRAFORM_AWS_INSTANCE_C7I_FLEX_8XLARGE
+ default "c7i-flex.12xlarge" if TERRAFORM_AWS_INSTANCE_C7I_FLEX_12XLARGE
+ default "c7i-flex.16xlarge" if TERRAFORM_AWS_INSTANCE_C7I_FLEX_16XLARGE
+ default "c7i-flex.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c7i.static b/terraform/aws/kconfigs/instance-types/Kconfig.c7i.static
new file mode 100644
index 00000000..87ff0480
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c7i.static
@@ -0,0 +1,113 @@
+# AWS C7I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C7I family"
+ default TERRAFORM_AWS_INSTANCE_C7I_LARGE
+ help
+ Select the specific instance size within the C7I family.
+
+config TERRAFORM_AWS_INSTANCE_C7I_LARGE
+ bool "c7i.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_XLARGE
+ bool "c7i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_2XLARGE
+ bool "c7i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_4XLARGE
+ bool "c7i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_8XLARGE
+ bool "c7i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_12XLARGE
+ bool "c7i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_16XLARGE
+ bool "c7i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_METAL_24XL
+ bool "c7i.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_24XLARGE
+ bool "c7i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_METAL_48XL
+ bool "c7i.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C7I_48XLARGE
+ bool "c7i.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C7I_SIZE
+ string
+ default "c7i.large" if TERRAFORM_AWS_INSTANCE_C7I_LARGE
+ default "c7i.xlarge" if TERRAFORM_AWS_INSTANCE_C7I_XLARGE
+ default "c7i.2xlarge" if TERRAFORM_AWS_INSTANCE_C7I_2XLARGE
+ default "c7i.4xlarge" if TERRAFORM_AWS_INSTANCE_C7I_4XLARGE
+ default "c7i.8xlarge" if TERRAFORM_AWS_INSTANCE_C7I_8XLARGE
+ default "c7i.12xlarge" if TERRAFORM_AWS_INSTANCE_C7I_12XLARGE
+ default "c7i.16xlarge" if TERRAFORM_AWS_INSTANCE_C7I_16XLARGE
+ default "c7i.metal-24xl" if TERRAFORM_AWS_INSTANCE_C7I_METAL_24XL
+ default "c7i.24xlarge" if TERRAFORM_AWS_INSTANCE_C7I_24XLARGE
+ default "c7i.metal-48xl" if TERRAFORM_AWS_INSTANCE_C7I_METAL_48XL
+ default "c7i.48xlarge" if TERRAFORM_AWS_INSTANCE_C7I_48XLARGE
+ default "c7i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c8g.static b/terraform/aws/kconfigs/instance-types/Kconfig.c8g.static
new file mode 100644
index 00000000..f162ff22
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c8g.static
@@ -0,0 +1,122 @@
+# AWS C8G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C8G family"
+ default TERRAFORM_AWS_INSTANCE_C8G_MEDIUM
+ help
+ Select the specific instance size within the C8G family.
+
+config TERRAFORM_AWS_INSTANCE_C8G_MEDIUM
+ bool "c8g.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_LARGE
+ bool "c8g.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_XLARGE
+ bool "c8g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_2XLARGE
+ bool "c8g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_4XLARGE
+ bool "c8g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_8XLARGE
+ bool "c8g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_12XLARGE
+ bool "c8g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_16XLARGE
+ bool "c8g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_24XLARGE
+ bool "c8g.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_METAL_24XL
+ bool "c8g.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_48XLARGE
+ bool "c8g.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8G_METAL_48XL
+ bool "c8g.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C8G_SIZE
+ string
+ default "c8g.medium" if TERRAFORM_AWS_INSTANCE_C8G_MEDIUM
+ default "c8g.large" if TERRAFORM_AWS_INSTANCE_C8G_LARGE
+ default "c8g.xlarge" if TERRAFORM_AWS_INSTANCE_C8G_XLARGE
+ default "c8g.2xlarge" if TERRAFORM_AWS_INSTANCE_C8G_2XLARGE
+ default "c8g.4xlarge" if TERRAFORM_AWS_INSTANCE_C8G_4XLARGE
+ default "c8g.8xlarge" if TERRAFORM_AWS_INSTANCE_C8G_8XLARGE
+ default "c8g.12xlarge" if TERRAFORM_AWS_INSTANCE_C8G_12XLARGE
+ default "c8g.16xlarge" if TERRAFORM_AWS_INSTANCE_C8G_16XLARGE
+ default "c8g.24xlarge" if TERRAFORM_AWS_INSTANCE_C8G_24XLARGE
+ default "c8g.metal-24xl" if TERRAFORM_AWS_INSTANCE_C8G_METAL_24XL
+ default "c8g.48xlarge" if TERRAFORM_AWS_INSTANCE_C8G_48XLARGE
+ default "c8g.metal-48xl" if TERRAFORM_AWS_INSTANCE_C8G_METAL_48XL
+ default "c8g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c8gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.c8gd.static
new file mode 100644
index 00000000..24a5bb0f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c8gd.static
@@ -0,0 +1,134 @@
+# AWS C8GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C8GD family"
+ default TERRAFORM_AWS_INSTANCE_C8GD_MEDIUM
+ help
+ Select the specific instance size within the C8GD family.
+
+config TERRAFORM_AWS_INSTANCE_C8GD_MEDIUM
+ bool "c8gd.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_LARGE
+ bool "c8gd.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_XLARGE
+ bool "c8gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_2XLARGE
+ bool "c8gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_4XLARGE
+ bool "c8gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_8XLARGE
+ bool "c8gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_12XLARGE
+ bool "c8gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_16XLARGE
+ bool "c8gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_24XLARGE
+ bool "c8gd.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_METAL_24XL
+ bool "c8gd.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_48XLARGE
+ bool "c8gd.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 11400 GB
+
+config TERRAFORM_AWS_INSTANCE_C8GD_METAL_48XL
+ bool "c8gd.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 11400 GB
+
+endchoice
+
+config TERRAFORM_AWS_C8GD_SIZE
+ string
+ default "c8gd.medium" if TERRAFORM_AWS_INSTANCE_C8GD_MEDIUM
+ default "c8gd.large" if TERRAFORM_AWS_INSTANCE_C8GD_LARGE
+ default "c8gd.xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_XLARGE
+ default "c8gd.2xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_2XLARGE
+ default "c8gd.4xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_4XLARGE
+ default "c8gd.8xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_8XLARGE
+ default "c8gd.12xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_12XLARGE
+ default "c8gd.16xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_16XLARGE
+ default "c8gd.24xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_24XLARGE
+ default "c8gd.metal-24xl" if TERRAFORM_AWS_INSTANCE_C8GD_METAL_24XL
+ default "c8gd.48xlarge" if TERRAFORM_AWS_INSTANCE_C8GD_48XLARGE
+ default "c8gd.metal-48xl" if TERRAFORM_AWS_INSTANCE_C8GD_METAL_48XL
+ default "c8gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.c8gn.static b/terraform/aws/kconfigs/instance-types/Kconfig.c8gn.static
new file mode 100644
index 00000000..d8227ae1
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.c8gn.static
@@ -0,0 +1,122 @@
+# AWS C8GN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for C8GN family"
+ default TERRAFORM_AWS_INSTANCE_C8GN_MEDIUM
+ help
+ Select the specific instance size within the C8GN family.
+
+config TERRAFORM_AWS_INSTANCE_C8GN_MEDIUM
+ bool "c8gn.medium"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_LARGE
+ bool "c8gn.large"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_XLARGE
+ bool "c8gn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_2XLARGE
+ bool "c8gn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_4XLARGE
+ bool "c8gn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_8XLARGE
+ bool "c8gn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_12XLARGE
+ bool "c8gn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 96.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_16XLARGE
+ bool "c8gn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_METAL_24XL
+ bool "c8gn.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 300 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_24XLARGE
+ bool "c8gn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 300 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_48XLARGE
+ bool "c8gn.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 600 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_C8GN_METAL_48XL
+ bool "c8gn.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 384.0 GB
+ Network: 600 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_C8GN_SIZE
+ string
+ default "c8gn.medium" if TERRAFORM_AWS_INSTANCE_C8GN_MEDIUM
+ default "c8gn.large" if TERRAFORM_AWS_INSTANCE_C8GN_LARGE
+ default "c8gn.xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_XLARGE
+ default "c8gn.2xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_2XLARGE
+ default "c8gn.4xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_4XLARGE
+ default "c8gn.8xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_8XLARGE
+ default "c8gn.12xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_12XLARGE
+ default "c8gn.16xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_16XLARGE
+ default "c8gn.metal-24xl" if TERRAFORM_AWS_INSTANCE_C8GN_METAL_24XL
+ default "c8gn.24xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_24XLARGE
+ default "c8gn.48xlarge" if TERRAFORM_AWS_INSTANCE_C8GN_48XLARGE
+ default "c8gn.metal-48xl" if TERRAFORM_AWS_INSTANCE_C8GN_METAL_48XL
+ default "c8gn.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.d2.static b/terraform/aws/kconfigs/instance-types/Kconfig.d2.static
new file mode 100644
index 00000000..bb8993d7
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.d2.static
@@ -0,0 +1,54 @@
+# AWS D2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for D2 family"
+ default TERRAFORM_AWS_INSTANCE_D2_XLARGE
+ help
+ Select the specific instance size within the D2 family.
+
+config TERRAFORM_AWS_INSTANCE_D2_XLARGE
+ bool "d2.xlarge"
+ help
+ vCPUs: 4
+ Memory: 30.5 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 6144 GB
+
+config TERRAFORM_AWS_INSTANCE_D2_2XLARGE
+ bool "d2.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 61.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 12288 GB
+
+config TERRAFORM_AWS_INSTANCE_D2_4XLARGE
+ bool "d2.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 122.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 24576 GB
+
+config TERRAFORM_AWS_INSTANCE_D2_8XLARGE
+ bool "d2.8xlarge"
+ help
+ vCPUs: 36
+ Memory: 244.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 49152 GB
+
+endchoice
+
+config TERRAFORM_AWS_D2_SIZE
+ string
+ default "d2.xlarge" if TERRAFORM_AWS_INSTANCE_D2_XLARGE
+ default "d2.2xlarge" if TERRAFORM_AWS_INSTANCE_D2_2XLARGE
+ default "d2.4xlarge" if TERRAFORM_AWS_INSTANCE_D2_4XLARGE
+ default "d2.8xlarge" if TERRAFORM_AWS_INSTANCE_D2_8XLARGE
+ default "d2.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.d3.static b/terraform/aws/kconfigs/instance-types/Kconfig.d3.static
new file mode 100644
index 00000000..1f20c90d
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.d3.static
@@ -0,0 +1,54 @@
+# AWS D3 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for D3 family"
+ default TERRAFORM_AWS_INSTANCE_D3_XLARGE
+ help
+ Select the specific instance size within the D3 family.
+
+config TERRAFORM_AWS_INSTANCE_D3_XLARGE
+ bool "d3.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 5940 GB
+
+config TERRAFORM_AWS_INSTANCE_D3_2XLARGE
+ bool "d3.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 11880 GB
+
+config TERRAFORM_AWS_INSTANCE_D3_4XLARGE
+ bool "d3.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 23760 GB
+
+config TERRAFORM_AWS_INSTANCE_D3_8XLARGE
+ bool "d3.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 47520 GB
+
+endchoice
+
+config TERRAFORM_AWS_D3_SIZE
+ string
+ default "d3.xlarge" if TERRAFORM_AWS_INSTANCE_D3_XLARGE
+ default "d3.2xlarge" if TERRAFORM_AWS_INSTANCE_D3_2XLARGE
+ default "d3.4xlarge" if TERRAFORM_AWS_INSTANCE_D3_4XLARGE
+ default "d3.8xlarge" if TERRAFORM_AWS_INSTANCE_D3_8XLARGE
+ default "d3.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.d3en.static b/terraform/aws/kconfigs/instance-types/Kconfig.d3en.static
new file mode 100644
index 00000000..90f2e629
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.d3en.static
@@ -0,0 +1,74 @@
+# AWS D3EN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for D3EN family"
+ default TERRAFORM_AWS_INSTANCE_D3EN_XLARGE
+ help
+ Select the specific instance size within the D3EN family.
+
+config TERRAFORM_AWS_INSTANCE_D3EN_XLARGE
+ bool "d3en.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 27960 GB
+
+config TERRAFORM_AWS_INSTANCE_D3EN_2XLARGE
+ bool "d3en.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 55920 GB
+
+config TERRAFORM_AWS_INSTANCE_D3EN_4XLARGE
+ bool "d3en.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 111840 GB
+
+config TERRAFORM_AWS_INSTANCE_D3EN_6XLARGE
+ bool "d3en.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 96.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 167760 GB
+
+config TERRAFORM_AWS_INSTANCE_D3EN_8XLARGE
+ bool "d3en.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 223680 GB
+
+config TERRAFORM_AWS_INSTANCE_D3EN_12XLARGE
+ bool "d3en.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 335520 GB
+
+endchoice
+
+config TERRAFORM_AWS_D3EN_SIZE
+ string
+ default "d3en.xlarge" if TERRAFORM_AWS_INSTANCE_D3EN_XLARGE
+ default "d3en.2xlarge" if TERRAFORM_AWS_INSTANCE_D3EN_2XLARGE
+ default "d3en.4xlarge" if TERRAFORM_AWS_INSTANCE_D3EN_4XLARGE
+ default "d3en.6xlarge" if TERRAFORM_AWS_INSTANCE_D3EN_6XLARGE
+ default "d3en.8xlarge" if TERRAFORM_AWS_INSTANCE_D3EN_8XLARGE
+ default "d3en.12xlarge" if TERRAFORM_AWS_INSTANCE_D3EN_12XLARGE
+ default "d3en.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.dl1.static b/terraform/aws/kconfigs/instance-types/Kconfig.dl1.static
new file mode 100644
index 00000000..ffeb7bdb
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.dl1.static
@@ -0,0 +1,24 @@
+# AWS DL1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for DL1 family"
+ default TERRAFORM_AWS_INSTANCE_DL1_24XLARGE
+ help
+ Select the specific instance size within the DL1 family.
+
+config TERRAFORM_AWS_INSTANCE_DL1_24XLARGE
+ bool "dl1.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 4x 100 Gigabit
+ Price: pricing varies
+ Instance storage: 4000 GB
+
+endchoice
+
+config TERRAFORM_AWS_DL1_SIZE
+ string
+ default "dl1.24xlarge" if TERRAFORM_AWS_INSTANCE_DL1_24XLARGE
+ default "dl1.24xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.f1.static b/terraform/aws/kconfigs/instance-types/Kconfig.f1.static
new file mode 100644
index 00000000..c99b4ba9
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.f1.static
@@ -0,0 +1,44 @@
+# AWS F1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for F1 family"
+ default TERRAFORM_AWS_INSTANCE_F1_2XLARGE
+ help
+ Select the specific instance size within the F1 family.
+
+config TERRAFORM_AWS_INSTANCE_F1_2XLARGE
+ bool "f1.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 122.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 470 GB
+
+config TERRAFORM_AWS_INSTANCE_F1_4XLARGE
+ bool "f1.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 244.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 940 GB
+
+config TERRAFORM_AWS_INSTANCE_F1_16XLARGE
+ bool "f1.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 976.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3760 GB
+
+endchoice
+
+config TERRAFORM_AWS_F1_SIZE
+ string
+ default "f1.2xlarge" if TERRAFORM_AWS_INSTANCE_F1_2XLARGE
+ default "f1.4xlarge" if TERRAFORM_AWS_INSTANCE_F1_4XLARGE
+ default "f1.16xlarge" if TERRAFORM_AWS_INSTANCE_F1_16XLARGE
+ default "f1.2xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.f2.static b/terraform/aws/kconfigs/instance-types/Kconfig.f2.static
new file mode 100644
index 00000000..af14d221
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.f2.static
@@ -0,0 +1,44 @@
+# AWS F2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for F2 family"
+ default TERRAFORM_AWS_INSTANCE_F2_6XLARGE
+ help
+ Select the specific instance size within the F2 family.
+
+config TERRAFORM_AWS_INSTANCE_F2_6XLARGE
+ bool "f2.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 256.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 940 GB
+
+config TERRAFORM_AWS_INSTANCE_F2_12XLARGE
+ bool "f2.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1880 GB
+
+config TERRAFORM_AWS_INSTANCE_F2_48XLARGE
+ bool "f2.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 2048.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 7520 GB
+
+endchoice
+
+config TERRAFORM_AWS_F2_SIZE
+ string
+ default "f2.6xlarge" if TERRAFORM_AWS_INSTANCE_F2_6XLARGE
+ default "f2.12xlarge" if TERRAFORM_AWS_INSTANCE_F2_12XLARGE
+ default "f2.48xlarge" if TERRAFORM_AWS_INSTANCE_F2_48XLARGE
+ default "f2.6xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.g4ad.static b/terraform/aws/kconfigs/instance-types/Kconfig.g4ad.static
new file mode 100644
index 00000000..3bb58be4
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.g4ad.static
@@ -0,0 +1,64 @@
+# AWS G4AD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for G4AD family"
+ default TERRAFORM_AWS_INSTANCE_G4AD_XLARGE
+ help
+ Select the specific instance size within the G4AD family.
+
+config TERRAFORM_AWS_INSTANCE_G4AD_XLARGE
+ bool "g4ad.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_G4AD_2XLARGE
+ bool "g4ad.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_G4AD_4XLARGE
+ bool "g4ad.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_G4AD_8XLARGE
+ bool "g4ad.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_G4AD_16XLARGE
+ bool "g4ad.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+endchoice
+
+config TERRAFORM_AWS_G4AD_SIZE
+ string
+ default "g4ad.xlarge" if TERRAFORM_AWS_INSTANCE_G4AD_XLARGE
+ default "g4ad.2xlarge" if TERRAFORM_AWS_INSTANCE_G4AD_2XLARGE
+ default "g4ad.4xlarge" if TERRAFORM_AWS_INSTANCE_G4AD_4XLARGE
+ default "g4ad.8xlarge" if TERRAFORM_AWS_INSTANCE_G4AD_8XLARGE
+ default "g4ad.16xlarge" if TERRAFORM_AWS_INSTANCE_G4AD_16XLARGE
+ default "g4ad.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.g4dn.static b/terraform/aws/kconfigs/instance-types/Kconfig.g4dn.static
new file mode 100644
index 00000000..456bba8b
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.g4dn.static
@@ -0,0 +1,84 @@
+# AWS G4DN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for G4DN family"
+ default TERRAFORM_AWS_INSTANCE_G4DN_XLARGE
+ help
+ Select the specific instance size within the G4DN family.
+
+config TERRAFORM_AWS_INSTANCE_G4DN_XLARGE
+ bool "g4dn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 125 GB
+
+config TERRAFORM_AWS_INSTANCE_G4DN_2XLARGE
+ bool "g4dn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 225 GB
+
+config TERRAFORM_AWS_INSTANCE_G4DN_4XLARGE
+ bool "g4dn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 225 GB
+
+config TERRAFORM_AWS_INSTANCE_G4DN_8XLARGE
+ bool "g4dn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_G4DN_12XLARGE
+ bool "g4dn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_G4DN_16XLARGE
+ bool "g4dn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_G4DN_METAL
+ bool "g4dn.metal"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+endchoice
+
+config TERRAFORM_AWS_G4DN_SIZE
+ string
+ default "g4dn.xlarge" if TERRAFORM_AWS_INSTANCE_G4DN_XLARGE
+ default "g4dn.2xlarge" if TERRAFORM_AWS_INSTANCE_G4DN_2XLARGE
+ default "g4dn.4xlarge" if TERRAFORM_AWS_INSTANCE_G4DN_4XLARGE
+ default "g4dn.8xlarge" if TERRAFORM_AWS_INSTANCE_G4DN_8XLARGE
+ default "g4dn.12xlarge" if TERRAFORM_AWS_INSTANCE_G4DN_12XLARGE
+ default "g4dn.16xlarge" if TERRAFORM_AWS_INSTANCE_G4DN_16XLARGE
+ default "g4dn.metal" if TERRAFORM_AWS_INSTANCE_G4DN_METAL
+ default "g4dn.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.g5.static b/terraform/aws/kconfigs/instance-types/Kconfig.g5.static
new file mode 100644
index 00000000..c4688fbf
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.g5.static
@@ -0,0 +1,94 @@
+# AWS G5 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for G5 family"
+ default TERRAFORM_AWS_INSTANCE_G5_XLARGE
+ help
+ Select the specific instance size within the G5 family.
+
+config TERRAFORM_AWS_INSTANCE_G5_XLARGE
+ bool "g5.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 250 GB
+
+config TERRAFORM_AWS_INSTANCE_G5_2XLARGE
+ bool "g5.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 450 GB
+
+config TERRAFORM_AWS_INSTANCE_G5_4XLARGE
+ bool "g5.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_G5_8XLARGE
+ bool "g5.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_G5_12XLARGE
+ bool "g5.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_G5_16XLARGE
+ bool "g5.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_G5_24XLARGE
+ bool "g5.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_G5_48XLARGE
+ bool "g5.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_G5_SIZE
+ string
+ default "g5.xlarge" if TERRAFORM_AWS_INSTANCE_G5_XLARGE
+ default "g5.2xlarge" if TERRAFORM_AWS_INSTANCE_G5_2XLARGE
+ default "g5.4xlarge" if TERRAFORM_AWS_INSTANCE_G5_4XLARGE
+ default "g5.8xlarge" if TERRAFORM_AWS_INSTANCE_G5_8XLARGE
+ default "g5.12xlarge" if TERRAFORM_AWS_INSTANCE_G5_12XLARGE
+ default "g5.16xlarge" if TERRAFORM_AWS_INSTANCE_G5_16XLARGE
+ default "g5.24xlarge" if TERRAFORM_AWS_INSTANCE_G5_24XLARGE
+ default "g5.48xlarge" if TERRAFORM_AWS_INSTANCE_G5_48XLARGE
+ default "g5.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.g5g.static b/terraform/aws/kconfigs/instance-types/Kconfig.g5g.static
new file mode 100644
index 00000000..896bce0a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.g5g.static
@@ -0,0 +1,68 @@
+# AWS G5G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for G5G family"
+ default TERRAFORM_AWS_INSTANCE_G5G_XLARGE
+ help
+ Select the specific instance size within the G5G family.
+
+config TERRAFORM_AWS_INSTANCE_G5G_XLARGE
+ bool "g5g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_G5G_2XLARGE
+ bool "g5g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_G5G_4XLARGE
+ bool "g5g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_G5G_8XLARGE
+ bool "g5g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 64.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_G5G_16XLARGE
+ bool "g5g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_G5G_METAL
+ bool "g5g.metal"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_G5G_SIZE
+ string
+ default "g5g.xlarge" if TERRAFORM_AWS_INSTANCE_G5G_XLARGE
+ default "g5g.2xlarge" if TERRAFORM_AWS_INSTANCE_G5G_2XLARGE
+ default "g5g.4xlarge" if TERRAFORM_AWS_INSTANCE_G5G_4XLARGE
+ default "g5g.8xlarge" if TERRAFORM_AWS_INSTANCE_G5G_8XLARGE
+ default "g5g.16xlarge" if TERRAFORM_AWS_INSTANCE_G5G_16XLARGE
+ default "g5g.metal" if TERRAFORM_AWS_INSTANCE_G5G_METAL
+ default "g5g.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.g6.static b/terraform/aws/kconfigs/instance-types/Kconfig.g6.static
new file mode 100644
index 00000000..3cc1ad9f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.g6.static
@@ -0,0 +1,94 @@
+# AWS G6 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for G6 family"
+ default TERRAFORM_AWS_INSTANCE_G6_XLARGE
+ help
+ Select the specific instance size within the G6 family.
+
+config TERRAFORM_AWS_INSTANCE_G6_XLARGE
+ bool "g6.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 250 GB
+
+config TERRAFORM_AWS_INSTANCE_G6_2XLARGE
+ bool "g6.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 450 GB
+
+config TERRAFORM_AWS_INSTANCE_G6_4XLARGE
+ bool "g6.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_G6_8XLARGE
+ bool "g6.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_G6_12XLARGE
+ bool "g6.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 3760 GB
+
+config TERRAFORM_AWS_INSTANCE_G6_16XLARGE
+ bool "g6.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1880 GB
+
+config TERRAFORM_AWS_INSTANCE_G6_24XLARGE
+ bool "g6.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 3760 GB
+
+config TERRAFORM_AWS_INSTANCE_G6_48XLARGE
+ bool "g6.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 7520 GB
+
+endchoice
+
+config TERRAFORM_AWS_G6_SIZE
+ string
+ default "g6.xlarge" if TERRAFORM_AWS_INSTANCE_G6_XLARGE
+ default "g6.2xlarge" if TERRAFORM_AWS_INSTANCE_G6_2XLARGE
+ default "g6.4xlarge" if TERRAFORM_AWS_INSTANCE_G6_4XLARGE
+ default "g6.8xlarge" if TERRAFORM_AWS_INSTANCE_G6_8XLARGE
+ default "g6.12xlarge" if TERRAFORM_AWS_INSTANCE_G6_12XLARGE
+ default "g6.16xlarge" if TERRAFORM_AWS_INSTANCE_G6_16XLARGE
+ default "g6.24xlarge" if TERRAFORM_AWS_INSTANCE_G6_24XLARGE
+ default "g6.48xlarge" if TERRAFORM_AWS_INSTANCE_G6_48XLARGE
+ default "g6.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.g6e.static b/terraform/aws/kconfigs/instance-types/Kconfig.g6e.static
new file mode 100644
index 00000000..bbcae709
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.g6e.static
@@ -0,0 +1,94 @@
+# AWS G6E instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for G6E family"
+ default TERRAFORM_AWS_INSTANCE_G6E_XLARGE
+ help
+ Select the specific instance size within the G6E family.
+
+config TERRAFORM_AWS_INSTANCE_G6E_XLARGE
+ bool "g6e.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 20 Gigabit
+ Price: pricing varies
+ Instance storage: 250 GB
+
+config TERRAFORM_AWS_INSTANCE_G6E_2XLARGE
+ bool "g6e.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 20 Gigabit
+ Price: pricing varies
+ Instance storage: 450 GB
+
+config TERRAFORM_AWS_INSTANCE_G6E_4XLARGE
+ bool "g6e.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_G6E_8XLARGE
+ bool "g6e.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_G6E_12XLARGE
+ bool "g6e.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_G6E_16XLARGE
+ bool "g6e.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 35 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_G6E_24XLARGE
+ bool "g6e.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_G6E_48XLARGE
+ bool "g6e.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 400 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_G6E_SIZE
+ string
+ default "g6e.xlarge" if TERRAFORM_AWS_INSTANCE_G6E_XLARGE
+ default "g6e.2xlarge" if TERRAFORM_AWS_INSTANCE_G6E_2XLARGE
+ default "g6e.4xlarge" if TERRAFORM_AWS_INSTANCE_G6E_4XLARGE
+ default "g6e.8xlarge" if TERRAFORM_AWS_INSTANCE_G6E_8XLARGE
+ default "g6e.12xlarge" if TERRAFORM_AWS_INSTANCE_G6E_12XLARGE
+ default "g6e.16xlarge" if TERRAFORM_AWS_INSTANCE_G6E_16XLARGE
+ default "g6e.24xlarge" if TERRAFORM_AWS_INSTANCE_G6E_24XLARGE
+ default "g6e.48xlarge" if TERRAFORM_AWS_INSTANCE_G6E_48XLARGE
+ default "g6e.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.g6f.static b/terraform/aws/kconfigs/instance-types/Kconfig.g6f.static
new file mode 100644
index 00000000..bfba1fea
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.g6f.static
@@ -0,0 +1,54 @@
+# AWS G6F instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for G6F family"
+ default TERRAFORM_AWS_INSTANCE_G6F_LARGE
+ help
+ Select the specific instance size within the G6F family.
+
+config TERRAFORM_AWS_INSTANCE_G6F_LARGE
+ bool "g6f.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 100 GB
+
+config TERRAFORM_AWS_INSTANCE_G6F_XLARGE
+ bool "g6f.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 100 GB
+
+config TERRAFORM_AWS_INSTANCE_G6F_2XLARGE
+ bool "g6f.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 200 GB
+
+config TERRAFORM_AWS_INSTANCE_G6F_4XLARGE
+ bool "g6f.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 450 GB
+
+endchoice
+
+config TERRAFORM_AWS_G6F_SIZE
+ string
+ default "g6f.large" if TERRAFORM_AWS_INSTANCE_G6F_LARGE
+ default "g6f.xlarge" if TERRAFORM_AWS_INSTANCE_G6F_XLARGE
+ default "g6f.2xlarge" if TERRAFORM_AWS_INSTANCE_G6F_2XLARGE
+ default "g6f.4xlarge" if TERRAFORM_AWS_INSTANCE_G6F_4XLARGE
+ default "g6f.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.gr6.static b/terraform/aws/kconfigs/instance-types/Kconfig.gr6.static
new file mode 100644
index 00000000..90131051
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.gr6.static
@@ -0,0 +1,34 @@
+# AWS GR6 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for GR6 family"
+ default TERRAFORM_AWS_INSTANCE_GR6_4XLARGE
+ help
+ Select the specific instance size within the GR6 family.
+
+config TERRAFORM_AWS_INSTANCE_GR6_4XLARGE
+ bool "gr6.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_GR6_8XLARGE
+ bool "gr6.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+endchoice
+
+config TERRAFORM_AWS_GR6_SIZE
+ string
+ default "gr6.4xlarge" if TERRAFORM_AWS_INSTANCE_GR6_4XLARGE
+ default "gr6.8xlarge" if TERRAFORM_AWS_INSTANCE_GR6_8XLARGE
+ default "gr6.4xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.gr6f.static b/terraform/aws/kconfigs/instance-types/Kconfig.gr6f.static
new file mode 100644
index 00000000..5347bb81
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.gr6f.static
@@ -0,0 +1,24 @@
+# AWS GR6F instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for GR6F family"
+ default TERRAFORM_AWS_INSTANCE_GR6F_4XLARGE
+ help
+ Select the specific instance size within the GR6F family.
+
+config TERRAFORM_AWS_INSTANCE_GR6F_4XLARGE
+ bool "gr6f.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 450 GB
+
+endchoice
+
+config TERRAFORM_AWS_GR6F_SIZE
+ string
+ default "gr6f.4xlarge" if TERRAFORM_AWS_INSTANCE_GR6F_4XLARGE
+ default "gr6f.4xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.h1.static b/terraform/aws/kconfigs/instance-types/Kconfig.h1.static
new file mode 100644
index 00000000..6b457990
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.h1.static
@@ -0,0 +1,54 @@
+# AWS H1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for H1 family"
+ default TERRAFORM_AWS_INSTANCE_H1_2XLARGE
+ help
+ Select the specific instance size within the H1 family.
+
+config TERRAFORM_AWS_INSTANCE_H1_2XLARGE
+ bool "h1.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 2000 GB
+
+config TERRAFORM_AWS_INSTANCE_H1_4XLARGE
+ bool "h1.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 4000 GB
+
+config TERRAFORM_AWS_INSTANCE_H1_8XLARGE
+ bool "h1.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 8000 GB
+
+config TERRAFORM_AWS_INSTANCE_H1_16XLARGE
+ bool "h1.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 16000 GB
+
+endchoice
+
+config TERRAFORM_AWS_H1_SIZE
+ string
+ default "h1.2xlarge" if TERRAFORM_AWS_INSTANCE_H1_2XLARGE
+ default "h1.4xlarge" if TERRAFORM_AWS_INSTANCE_H1_4XLARGE
+ default "h1.8xlarge" if TERRAFORM_AWS_INSTANCE_H1_8XLARGE
+ default "h1.16xlarge" if TERRAFORM_AWS_INSTANCE_H1_16XLARGE
+ default "h1.2xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.hpc7g.static b/terraform/aws/kconfigs/instance-types/Kconfig.hpc7g.static
new file mode 100644
index 00000000..d9246aa6
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.hpc7g.static
@@ -0,0 +1,41 @@
+# AWS HPC7G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for HPC7G family"
+ default TERRAFORM_AWS_INSTANCE_HPC7G_4XLARGE
+ help
+ Select the specific instance size within the HPC7G family.
+
+config TERRAFORM_AWS_INSTANCE_HPC7G_4XLARGE
+ bool "hpc7g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_HPC7G_8XLARGE
+ bool "hpc7g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_HPC7G_16XLARGE
+ bool "hpc7g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 128.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_HPC7G_SIZE
+ string
+ default "hpc7g.4xlarge" if TERRAFORM_AWS_INSTANCE_HPC7G_4XLARGE
+ default "hpc7g.8xlarge" if TERRAFORM_AWS_INSTANCE_HPC7G_8XLARGE
+ default "hpc7g.16xlarge" if TERRAFORM_AWS_INSTANCE_HPC7G_16XLARGE
+ default "hpc7g.4xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i2.static b/terraform/aws/kconfigs/instance-types/Kconfig.i2.static
new file mode 100644
index 00000000..530aa0df
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i2.static
@@ -0,0 +1,54 @@
+# AWS I2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I2 family"
+ default TERRAFORM_AWS_INSTANCE_I2_XLARGE
+ help
+ Select the specific instance size within the I2 family.
+
+config TERRAFORM_AWS_INSTANCE_I2_XLARGE
+ bool "i2.xlarge"
+ help
+ vCPUs: 4
+ Memory: 30.5 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 800 GB
+
+config TERRAFORM_AWS_INSTANCE_I2_2XLARGE
+ bool "i2.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 61.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 1600 GB
+
+config TERRAFORM_AWS_INSTANCE_I2_4XLARGE
+ bool "i2.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 122.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 3200 GB
+
+config TERRAFORM_AWS_INSTANCE_I2_8XLARGE
+ bool "i2.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 244.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 6400 GB
+
+endchoice
+
+config TERRAFORM_AWS_I2_SIZE
+ string
+ default "i2.xlarge" if TERRAFORM_AWS_INSTANCE_I2_XLARGE
+ default "i2.2xlarge" if TERRAFORM_AWS_INSTANCE_I2_2XLARGE
+ default "i2.4xlarge" if TERRAFORM_AWS_INSTANCE_I2_4XLARGE
+ default "i2.8xlarge" if TERRAFORM_AWS_INSTANCE_I2_8XLARGE
+ default "i2.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i3.static b/terraform/aws/kconfigs/instance-types/Kconfig.i3.static
new file mode 100644
index 00000000..acf41e1a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i3.static
@@ -0,0 +1,74 @@
+# AWS I3 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I3 family"
+ default TERRAFORM_AWS_INSTANCE_I3_LARGE
+ help
+ Select the specific instance size within the I3 family.
+
+config TERRAFORM_AWS_INSTANCE_I3_LARGE
+ bool "i3.large"
+ help
+ vCPUs: 2
+ Memory: 15.2 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 475 GB
+
+config TERRAFORM_AWS_INSTANCE_I3_XLARGE
+ bool "i3.xlarge"
+ help
+ vCPUs: 4
+ Memory: 30.5 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_I3_2XLARGE
+ bool "i3.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 61.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_I3_4XLARGE
+ bool "i3.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 122.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_I3_8XLARGE
+ bool "i3.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 244.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+config TERRAFORM_AWS_INSTANCE_I3_16XLARGE
+ bool "i3.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 488.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 15200 GB
+
+endchoice
+
+config TERRAFORM_AWS_I3_SIZE
+ string
+ default "i3.large" if TERRAFORM_AWS_INSTANCE_I3_LARGE
+ default "i3.xlarge" if TERRAFORM_AWS_INSTANCE_I3_XLARGE
+ default "i3.2xlarge" if TERRAFORM_AWS_INSTANCE_I3_2XLARGE
+ default "i3.4xlarge" if TERRAFORM_AWS_INSTANCE_I3_4XLARGE
+ default "i3.8xlarge" if TERRAFORM_AWS_INSTANCE_I3_8XLARGE
+ default "i3.16xlarge" if TERRAFORM_AWS_INSTANCE_I3_16XLARGE
+ default "i3.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i3en.static b/terraform/aws/kconfigs/instance-types/Kconfig.i3en.static
new file mode 100644
index 00000000..9dbab48d
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i3en.static
@@ -0,0 +1,94 @@
+# AWS I3EN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I3EN family"
+ default TERRAFORM_AWS_INSTANCE_I3EN_LARGE
+ help
+ Select the specific instance size within the I3EN family.
+
+config TERRAFORM_AWS_INSTANCE_I3EN_LARGE
+ bool "i3en.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1250 GB
+
+config TERRAFORM_AWS_INSTANCE_I3EN_XLARGE
+ bool "i3en.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 2500 GB
+
+config TERRAFORM_AWS_INSTANCE_I3EN_2XLARGE
+ bool "i3en.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 5000 GB
+
+config TERRAFORM_AWS_INSTANCE_I3EN_3XLARGE
+ bool "i3en.3xlarge"
+ help
+ vCPUs: 12
+ Memory: 96.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_I3EN_6XLARGE
+ bool "i3en.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 192.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_I3EN_12XLARGE
+ bool "i3en.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 30000 GB
+
+config TERRAFORM_AWS_INSTANCE_I3EN_24XLARGE
+ bool "i3en.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 60000 GB
+
+config TERRAFORM_AWS_INSTANCE_I3EN_METAL
+ bool "i3en.metal"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 60000 GB
+
+endchoice
+
+config TERRAFORM_AWS_I3EN_SIZE
+ string
+ default "i3en.large" if TERRAFORM_AWS_INSTANCE_I3EN_LARGE
+ default "i3en.xlarge" if TERRAFORM_AWS_INSTANCE_I3EN_XLARGE
+ default "i3en.2xlarge" if TERRAFORM_AWS_INSTANCE_I3EN_2XLARGE
+ default "i3en.3xlarge" if TERRAFORM_AWS_INSTANCE_I3EN_3XLARGE
+ default "i3en.6xlarge" if TERRAFORM_AWS_INSTANCE_I3EN_6XLARGE
+ default "i3en.12xlarge" if TERRAFORM_AWS_INSTANCE_I3EN_12XLARGE
+ default "i3en.24xlarge" if TERRAFORM_AWS_INSTANCE_I3EN_24XLARGE
+ default "i3en.metal" if TERRAFORM_AWS_INSTANCE_I3EN_METAL
+ default "i3en.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i4g.static b/terraform/aws/kconfigs/instance-types/Kconfig.i4g.static
new file mode 100644
index 00000000..17174842
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i4g.static
@@ -0,0 +1,74 @@
+# AWS I4G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I4G family"
+ default TERRAFORM_AWS_INSTANCE_I4G_LARGE
+ help
+ Select the specific instance size within the I4G family.
+
+config TERRAFORM_AWS_INSTANCE_I4G_LARGE
+ bool "i4g.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 468 GB
+
+config TERRAFORM_AWS_INSTANCE_I4G_XLARGE
+ bool "i4g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 937 GB
+
+config TERRAFORM_AWS_INSTANCE_I4G_2XLARGE
+ bool "i4g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1875 GB
+
+config TERRAFORM_AWS_INSTANCE_I4G_4XLARGE
+ bool "i4g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3750 GB
+
+config TERRAFORM_AWS_INSTANCE_I4G_8XLARGE
+ bool "i4g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_I4G_16XLARGE
+ bool "i4g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+endchoice
+
+config TERRAFORM_AWS_I4G_SIZE
+ string
+ default "i4g.large" if TERRAFORM_AWS_INSTANCE_I4G_LARGE
+ default "i4g.xlarge" if TERRAFORM_AWS_INSTANCE_I4G_XLARGE
+ default "i4g.2xlarge" if TERRAFORM_AWS_INSTANCE_I4G_2XLARGE
+ default "i4g.4xlarge" if TERRAFORM_AWS_INSTANCE_I4G_4XLARGE
+ default "i4g.8xlarge" if TERRAFORM_AWS_INSTANCE_I4G_8XLARGE
+ default "i4g.16xlarge" if TERRAFORM_AWS_INSTANCE_I4G_16XLARGE
+ default "i4g.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i4i.static b/terraform/aws/kconfigs/instance-types/Kconfig.i4i.static
new file mode 100644
index 00000000..869e80f2
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i4i.static
@@ -0,0 +1,114 @@
+# AWS I4I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I4I family"
+ default TERRAFORM_AWS_INSTANCE_I4I_LARGE
+ help
+ Select the specific instance size within the I4I family.
+
+config TERRAFORM_AWS_INSTANCE_I4I_LARGE
+ bool "i4i.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.117/hour
+ Instance storage: 468 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_XLARGE
+ bool "i4i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.234/hour
+ Instance storage: 937 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_2XLARGE
+ bool "i4i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12 Gigabit
+ Price: $0.468/hour
+ Instance storage: 1875 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_4XLARGE
+ bool "i4i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: $0.936/hour
+ Instance storage: 3750 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_8XLARGE
+ bool "i4i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 18.75 Gigabit
+ Price: $1.872/hour
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_12XLARGE
+ bool "i4i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 28.12 Gigabit
+ Price: pricing varies
+ Instance storage: 11250 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_16XLARGE
+ bool "i4i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 37.5 Gigabit
+ Price: $3.744/hour
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_24XLARGE
+ bool "i4i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 56.25 Gigabit
+ Price: pricing varies
+ Instance storage: 22500 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_METAL
+ bool "i4i.metal"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 30000 GB
+
+config TERRAFORM_AWS_INSTANCE_I4I_32XLARGE
+ bool "i4i.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 75 Gigabit
+ Price: $7.488/hour
+ Instance storage: 30000 GB
+
+endchoice
+
+config TERRAFORM_AWS_I4I_SIZE
+ string
+ default "i4i.large" if TERRAFORM_AWS_INSTANCE_I4I_LARGE
+ default "i4i.xlarge" if TERRAFORM_AWS_INSTANCE_I4I_XLARGE
+ default "i4i.2xlarge" if TERRAFORM_AWS_INSTANCE_I4I_2XLARGE
+ default "i4i.4xlarge" if TERRAFORM_AWS_INSTANCE_I4I_4XLARGE
+ default "i4i.8xlarge" if TERRAFORM_AWS_INSTANCE_I4I_8XLARGE
+ default "i4i.12xlarge" if TERRAFORM_AWS_INSTANCE_I4I_12XLARGE
+ default "i4i.16xlarge" if TERRAFORM_AWS_INSTANCE_I4I_16XLARGE
+ default "i4i.24xlarge" if TERRAFORM_AWS_INSTANCE_I4I_24XLARGE
+ default "i4i.metal" if TERRAFORM_AWS_INSTANCE_I4I_METAL
+ default "i4i.32xlarge" if TERRAFORM_AWS_INSTANCE_I4I_32XLARGE
+ default "i4i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i7i.static b/terraform/aws/kconfigs/instance-types/Kconfig.i7i.static
new file mode 100644
index 00000000..ff9e91c2
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i7i.static
@@ -0,0 +1,124 @@
+# AWS I7I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I7I family"
+ default TERRAFORM_AWS_INSTANCE_I7I_LARGE
+ help
+ Select the specific instance size within the I7I family.
+
+config TERRAFORM_AWS_INSTANCE_I7I_LARGE
+ bool "i7i.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 468 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_XLARGE
+ bool "i7i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 937 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_2XLARGE
+ bool "i7i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1875 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_4XLARGE
+ bool "i7i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3750 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_8XLARGE
+ bool "i7i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_12XLARGE
+ bool "i7i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: Up to 28 Gigabit
+ Price: pricing varies
+ Instance storage: 11250 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_16XLARGE
+ bool "i7i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: Up to 37.5 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_METAL_24XL
+ bool "i7i.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: Up to 56.25 Gigabit
+ Price: pricing varies
+ Instance storage: 22500 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_24XLARGE
+ bool "i7i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: Up to 56.25 Gigabit
+ Price: pricing varies
+ Instance storage: 22500 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_METAL_48XL
+ bool "i7i.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: Up to 100 Gigabit
+ Price: pricing varies
+ Instance storage: 45000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7I_48XLARGE
+ bool "i7i.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: Up to 100 Gigabit
+ Price: pricing varies
+ Instance storage: 45000 GB
+
+endchoice
+
+config TERRAFORM_AWS_I7I_SIZE
+ string
+ default "i7i.large" if TERRAFORM_AWS_INSTANCE_I7I_LARGE
+ default "i7i.xlarge" if TERRAFORM_AWS_INSTANCE_I7I_XLARGE
+ default "i7i.2xlarge" if TERRAFORM_AWS_INSTANCE_I7I_2XLARGE
+ default "i7i.4xlarge" if TERRAFORM_AWS_INSTANCE_I7I_4XLARGE
+ default "i7i.8xlarge" if TERRAFORM_AWS_INSTANCE_I7I_8XLARGE
+ default "i7i.12xlarge" if TERRAFORM_AWS_INSTANCE_I7I_12XLARGE
+ default "i7i.16xlarge" if TERRAFORM_AWS_INSTANCE_I7I_16XLARGE
+ default "i7i.metal-24xl" if TERRAFORM_AWS_INSTANCE_I7I_METAL_24XL
+ default "i7i.24xlarge" if TERRAFORM_AWS_INSTANCE_I7I_24XLARGE
+ default "i7i.metal-48xl" if TERRAFORM_AWS_INSTANCE_I7I_METAL_48XL
+ default "i7i.48xlarge" if TERRAFORM_AWS_INSTANCE_I7I_48XLARGE
+ default "i7i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i7ie.static b/terraform/aws/kconfigs/instance-types/Kconfig.i7ie.static
new file mode 100644
index 00000000..96739ce5
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i7ie.static
@@ -0,0 +1,124 @@
+# AWS I7IE instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I7IE family"
+ default TERRAFORM_AWS_INSTANCE_I7IE_LARGE
+ help
+ Select the specific instance size within the I7IE family.
+
+config TERRAFORM_AWS_INSTANCE_I7IE_LARGE
+ bool "i7ie.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1250 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_XLARGE
+ bool "i7ie.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 2500 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_2XLARGE
+ bool "i7ie.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 5000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_3XLARGE
+ bool "i7ie.3xlarge"
+ help
+ vCPUs: 12
+ Memory: 96.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_6XLARGE
+ bool "i7ie.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 192.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_12XLARGE
+ bool "i7ie.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+ Instance storage: 30000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_18XLARGE
+ bool "i7ie.18xlarge"
+ help
+ vCPUs: 72
+ Memory: 576.0 GB
+ Network: Up to 75 Gigabit
+ Price: pricing varies
+ Instance storage: 45000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_24XLARGE
+ bool "i7ie.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: Up to 100 Gigabit
+ Price: pricing varies
+ Instance storage: 60000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_METAL_24XL
+ bool "i7ie.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: Up to 100 Gigabit
+ Price: pricing varies
+ Instance storage: 60000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_METAL_48XL
+ bool "i7ie.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 120000 GB
+
+config TERRAFORM_AWS_INSTANCE_I7IE_48XLARGE
+ bool "i7ie.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 120000 GB
+
+endchoice
+
+config TERRAFORM_AWS_I7IE_SIZE
+ string
+ default "i7ie.large" if TERRAFORM_AWS_INSTANCE_I7IE_LARGE
+ default "i7ie.xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_XLARGE
+ default "i7ie.2xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_2XLARGE
+ default "i7ie.3xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_3XLARGE
+ default "i7ie.6xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_6XLARGE
+ default "i7ie.12xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_12XLARGE
+ default "i7ie.18xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_18XLARGE
+ default "i7ie.24xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_24XLARGE
+ default "i7ie.metal-24xl" if TERRAFORM_AWS_INSTANCE_I7IE_METAL_24XL
+ default "i7ie.metal-48xl" if TERRAFORM_AWS_INSTANCE_I7IE_METAL_48XL
+ default "i7ie.48xlarge" if TERRAFORM_AWS_INSTANCE_I7IE_48XLARGE
+ default "i7ie.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i8g.static b/terraform/aws/kconfigs/instance-types/Kconfig.i8g.static
new file mode 100644
index 00000000..11245504
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i8g.static
@@ -0,0 +1,114 @@
+# AWS I8G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I8G family"
+ default TERRAFORM_AWS_INSTANCE_I8G_LARGE
+ help
+ Select the specific instance size within the I8G family.
+
+config TERRAFORM_AWS_INSTANCE_I8G_LARGE
+ bool "i8g.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 468 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_XLARGE
+ bool "i8g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 937 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_2XLARGE
+ bool "i8g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1875 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_4XLARGE
+ bool "i8g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3750 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_8XLARGE
+ bool "i8g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_12XLARGE
+ bool "i8g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: Up to 28.12 Gigabit
+ Price: pricing varies
+ Instance storage: 11250 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_16XLARGE
+ bool "i8g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: Up to 37.5 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_24XLARGE
+ bool "i8g.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: Up to 56.25 Gigabit
+ Price: pricing varies
+ Instance storage: 22500 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_METAL_24XL
+ bool "i8g.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: Up to 56.25 Gigabit
+ Price: pricing varies
+ Instance storage: 22500 GB
+
+config TERRAFORM_AWS_INSTANCE_I8G_48XLARGE
+ bool "i8g.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: Up to 100 Gigabit
+ Price: pricing varies
+ Instance storage: 45000 GB
+
+endchoice
+
+config TERRAFORM_AWS_I8G_SIZE
+ string
+ default "i8g.large" if TERRAFORM_AWS_INSTANCE_I8G_LARGE
+ default "i8g.xlarge" if TERRAFORM_AWS_INSTANCE_I8G_XLARGE
+ default "i8g.2xlarge" if TERRAFORM_AWS_INSTANCE_I8G_2XLARGE
+ default "i8g.4xlarge" if TERRAFORM_AWS_INSTANCE_I8G_4XLARGE
+ default "i8g.8xlarge" if TERRAFORM_AWS_INSTANCE_I8G_8XLARGE
+ default "i8g.12xlarge" if TERRAFORM_AWS_INSTANCE_I8G_12XLARGE
+ default "i8g.16xlarge" if TERRAFORM_AWS_INSTANCE_I8G_16XLARGE
+ default "i8g.24xlarge" if TERRAFORM_AWS_INSTANCE_I8G_24XLARGE
+ default "i8g.metal-24xl" if TERRAFORM_AWS_INSTANCE_I8G_METAL_24XL
+ default "i8g.48xlarge" if TERRAFORM_AWS_INSTANCE_I8G_48XLARGE
+ default "i8g.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.i8ge.static b/terraform/aws/kconfigs/instance-types/Kconfig.i8ge.static
new file mode 100644
index 00000000..35c10a5b
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.i8ge.static
@@ -0,0 +1,124 @@
+# AWS I8GE instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for I8GE family"
+ default TERRAFORM_AWS_INSTANCE_I8GE_LARGE
+ help
+ Select the specific instance size within the I8GE family.
+
+config TERRAFORM_AWS_INSTANCE_I8GE_LARGE
+ bool "i8ge.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1250 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_XLARGE
+ bool "i8ge.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 2500 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_2XLARGE
+ bool "i8ge.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 5000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_3XLARGE
+ bool "i8ge.3xlarge"
+ help
+ vCPUs: 12
+ Memory: 96.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_6XLARGE
+ bool "i8ge.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 192.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_12XLARGE
+ bool "i8ge.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 30000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_18XLARGE
+ bool "i8ge.18xlarge"
+ help
+ vCPUs: 72
+ Memory: 576.0 GB
+ Network: 112.5 Gigabit
+ Price: pricing varies
+ Instance storage: 45000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_24XLARGE
+ bool "i8ge.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+ Instance storage: 60000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_METAL_24XL
+ bool "i8ge.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+ Instance storage: 60000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_48XLARGE
+ bool "i8ge.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 300 Gigabit
+ Price: pricing varies
+ Instance storage: 120000 GB
+
+config TERRAFORM_AWS_INSTANCE_I8GE_METAL_48XL
+ bool "i8ge.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 300 Gigabit
+ Price: pricing varies
+ Instance storage: 120000 GB
+
+endchoice
+
+config TERRAFORM_AWS_I8GE_SIZE
+ string
+ default "i8ge.large" if TERRAFORM_AWS_INSTANCE_I8GE_LARGE
+ default "i8ge.xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_XLARGE
+ default "i8ge.2xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_2XLARGE
+ default "i8ge.3xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_3XLARGE
+ default "i8ge.6xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_6XLARGE
+ default "i8ge.12xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_12XLARGE
+ default "i8ge.18xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_18XLARGE
+ default "i8ge.24xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_24XLARGE
+ default "i8ge.metal-24xl" if TERRAFORM_AWS_INSTANCE_I8GE_METAL_24XL
+ default "i8ge.48xlarge" if TERRAFORM_AWS_INSTANCE_I8GE_48XLARGE
+ default "i8ge.metal-48xl" if TERRAFORM_AWS_INSTANCE_I8GE_METAL_48XL
+ default "i8ge.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.im4gn.static b/terraform/aws/kconfigs/instance-types/Kconfig.im4gn.static
new file mode 100644
index 00000000..55abbcb2
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.im4gn.static
@@ -0,0 +1,74 @@
+# AWS IM4GN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for IM4GN family"
+ default TERRAFORM_AWS_INSTANCE_IM4GN_LARGE
+ help
+ Select the specific instance size within the IM4GN family.
+
+config TERRAFORM_AWS_INSTANCE_IM4GN_LARGE
+ bool "im4gn.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 937 GB
+
+config TERRAFORM_AWS_INSTANCE_IM4GN_XLARGE
+ bool "im4gn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1875 GB
+
+config TERRAFORM_AWS_INSTANCE_IM4GN_2XLARGE
+ bool "im4gn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3750 GB
+
+config TERRAFORM_AWS_INSTANCE_IM4GN_4XLARGE
+ bool "im4gn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_IM4GN_8XLARGE
+ bool "im4gn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_IM4GN_16XLARGE
+ bool "im4gn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 30000 GB
+
+endchoice
+
+config TERRAFORM_AWS_IM4GN_SIZE
+ string
+ default "im4gn.large" if TERRAFORM_AWS_INSTANCE_IM4GN_LARGE
+ default "im4gn.xlarge" if TERRAFORM_AWS_INSTANCE_IM4GN_XLARGE
+ default "im4gn.2xlarge" if TERRAFORM_AWS_INSTANCE_IM4GN_2XLARGE
+ default "im4gn.4xlarge" if TERRAFORM_AWS_INSTANCE_IM4GN_4XLARGE
+ default "im4gn.8xlarge" if TERRAFORM_AWS_INSTANCE_IM4GN_8XLARGE
+ default "im4gn.16xlarge" if TERRAFORM_AWS_INSTANCE_IM4GN_16XLARGE
+ default "im4gn.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.inf1.static b/terraform/aws/kconfigs/instance-types/Kconfig.inf1.static
new file mode 100644
index 00000000..f67d689d
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.inf1.static
@@ -0,0 +1,50 @@
+# AWS INF1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for INF1 family"
+ default TERRAFORM_AWS_INSTANCE_INF1_XLARGE
+ help
+ Select the specific instance size within the INF1 family.
+
+config TERRAFORM_AWS_INSTANCE_INF1_XLARGE
+ bool "inf1.xlarge"
+ help
+ vCPUs: 4
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_INF1_2XLARGE
+ bool "inf1.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_INF1_6XLARGE
+ bool "inf1.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 48.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_INF1_24XLARGE
+ bool "inf1.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_INF1_SIZE
+ string
+ default "inf1.xlarge" if TERRAFORM_AWS_INSTANCE_INF1_XLARGE
+ default "inf1.2xlarge" if TERRAFORM_AWS_INSTANCE_INF1_2XLARGE
+ default "inf1.6xlarge" if TERRAFORM_AWS_INSTANCE_INF1_6XLARGE
+ default "inf1.24xlarge" if TERRAFORM_AWS_INSTANCE_INF1_24XLARGE
+ default "inf1.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.inf2.static b/terraform/aws/kconfigs/instance-types/Kconfig.inf2.static
new file mode 100644
index 00000000..0c2975e1
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.inf2.static
@@ -0,0 +1,50 @@
+# AWS INF2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for INF2 family"
+ default TERRAFORM_AWS_INSTANCE_INF2_XLARGE
+ help
+ Select the specific instance size within the INF2 family.
+
+config TERRAFORM_AWS_INSTANCE_INF2_XLARGE
+ bool "inf2.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_INF2_8XLARGE
+ bool "inf2.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_INF2_24XLARGE
+ bool "inf2.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_INF2_48XLARGE
+ bool "inf2.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_INF2_SIZE
+ string
+ default "inf2.xlarge" if TERRAFORM_AWS_INSTANCE_INF2_XLARGE
+ default "inf2.8xlarge" if TERRAFORM_AWS_INSTANCE_INF2_8XLARGE
+ default "inf2.24xlarge" if TERRAFORM_AWS_INSTANCE_INF2_24XLARGE
+ default "inf2.48xlarge" if TERRAFORM_AWS_INSTANCE_INF2_48XLARGE
+ default "inf2.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.is4gen.static b/terraform/aws/kconfigs/instance-types/Kconfig.is4gen.static
new file mode 100644
index 00000000..5bbab9c6
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.is4gen.static
@@ -0,0 +1,74 @@
+# AWS IS4GEN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for IS4GEN family"
+ default TERRAFORM_AWS_INSTANCE_IS4GEN_MEDIUM
+ help
+ Select the specific instance size within the IS4GEN family.
+
+config TERRAFORM_AWS_INSTANCE_IS4GEN_MEDIUM
+ bool "is4gen.medium"
+ help
+ vCPUs: 1
+ Memory: 6.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 937 GB
+
+config TERRAFORM_AWS_INSTANCE_IS4GEN_LARGE
+ bool "is4gen.large"
+ help
+ vCPUs: 2
+ Memory: 12.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1875 GB
+
+config TERRAFORM_AWS_INSTANCE_IS4GEN_XLARGE
+ bool "is4gen.xlarge"
+ help
+ vCPUs: 4
+ Memory: 24.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3750 GB
+
+config TERRAFORM_AWS_INSTANCE_IS4GEN_2XLARGE
+ bool "is4gen.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 48.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 7500 GB
+
+config TERRAFORM_AWS_INSTANCE_IS4GEN_4XLARGE
+ bool "is4gen.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 96.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 15000 GB
+
+config TERRAFORM_AWS_INSTANCE_IS4GEN_8XLARGE
+ bool "is4gen.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 192.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 30000 GB
+
+endchoice
+
+config TERRAFORM_AWS_IS4GEN_SIZE
+ string
+ default "is4gen.medium" if TERRAFORM_AWS_INSTANCE_IS4GEN_MEDIUM
+ default "is4gen.large" if TERRAFORM_AWS_INSTANCE_IS4GEN_LARGE
+ default "is4gen.xlarge" if TERRAFORM_AWS_INSTANCE_IS4GEN_XLARGE
+ default "is4gen.2xlarge" if TERRAFORM_AWS_INSTANCE_IS4GEN_2XLARGE
+ default "is4gen.4xlarge" if TERRAFORM_AWS_INSTANCE_IS4GEN_4XLARGE
+ default "is4gen.8xlarge" if TERRAFORM_AWS_INSTANCE_IS4GEN_8XLARGE
+ default "is4gen.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m1.static b/terraform/aws/kconfigs/instance-types/Kconfig.m1.static
new file mode 100644
index 00000000..8411e0fa
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m1.static
@@ -0,0 +1,54 @@
+# AWS M1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M1 family"
+ default TERRAFORM_AWS_INSTANCE_M1_SMALL
+ help
+ Select the specific instance size within the M1 family.
+
+config TERRAFORM_AWS_INSTANCE_M1_SMALL
+ bool "m1.small"
+ help
+ vCPUs: 1
+ Memory: 1.7 GB
+ Network: Low
+ Price: pricing varies
+ Instance storage: 160 GB
+
+config TERRAFORM_AWS_INSTANCE_M1_MEDIUM
+ bool "m1.medium"
+ help
+ vCPUs: 1
+ Memory: 3.7 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 410 GB
+
+config TERRAFORM_AWS_INSTANCE_M1_LARGE
+ bool "m1.large"
+ help
+ vCPUs: 2
+ Memory: 7.5 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 840 GB
+
+config TERRAFORM_AWS_INSTANCE_M1_XLARGE
+ bool "m1.xlarge"
+ help
+ vCPUs: 4
+ Memory: 15.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 1680 GB
+
+endchoice
+
+config TERRAFORM_AWS_M1_SIZE
+ string
+ default "m1.small" if TERRAFORM_AWS_INSTANCE_M1_SMALL
+ default "m1.medium" if TERRAFORM_AWS_INSTANCE_M1_MEDIUM
+ default "m1.large" if TERRAFORM_AWS_INSTANCE_M1_LARGE
+ default "m1.xlarge" if TERRAFORM_AWS_INSTANCE_M1_XLARGE
+ default "m1.small"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m2.static b/terraform/aws/kconfigs/instance-types/Kconfig.m2.static
new file mode 100644
index 00000000..e9408bdd
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m2.static
@@ -0,0 +1,44 @@
+# AWS M2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M2 family"
+ default TERRAFORM_AWS_INSTANCE_M2_XLARGE
+ help
+ Select the specific instance size within the M2 family.
+
+config TERRAFORM_AWS_INSTANCE_M2_XLARGE
+ bool "m2.xlarge"
+ help
+ vCPUs: 2
+ Memory: 17.1 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 420 GB
+
+config TERRAFORM_AWS_INSTANCE_M2_2XLARGE
+ bool "m2.2xlarge"
+ help
+ vCPUs: 4
+ Memory: 34.2 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 850 GB
+
+config TERRAFORM_AWS_INSTANCE_M2_4XLARGE
+ bool "m2.4xlarge"
+ help
+ vCPUs: 8
+ Memory: 68.4 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 1680 GB
+
+endchoice
+
+config TERRAFORM_AWS_M2_SIZE
+ string
+ default "m2.xlarge" if TERRAFORM_AWS_INSTANCE_M2_XLARGE
+ default "m2.2xlarge" if TERRAFORM_AWS_INSTANCE_M2_2XLARGE
+ default "m2.4xlarge" if TERRAFORM_AWS_INSTANCE_M2_4XLARGE
+ default "m2.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m3.static b/terraform/aws/kconfigs/instance-types/Kconfig.m3.static
new file mode 100644
index 00000000..eaa1f849
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m3.static
@@ -0,0 +1,54 @@
+# AWS M3 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M3 family"
+ default TERRAFORM_AWS_INSTANCE_M3_MEDIUM
+ help
+ Select the specific instance size within the M3 family.
+
+config TERRAFORM_AWS_INSTANCE_M3_MEDIUM
+ bool "m3.medium"
+ help
+ vCPUs: 1
+ Memory: 3.8 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 4 GB
+
+config TERRAFORM_AWS_INSTANCE_M3_LARGE
+ bool "m3.large"
+ help
+ vCPUs: 2
+ Memory: 7.5 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 32 GB
+
+config TERRAFORM_AWS_INSTANCE_M3_XLARGE
+ bool "m3.xlarge"
+ help
+ vCPUs: 4
+ Memory: 15.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 80 GB
+
+config TERRAFORM_AWS_INSTANCE_M3_2XLARGE
+ bool "m3.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 30.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 160 GB
+
+endchoice
+
+config TERRAFORM_AWS_M3_SIZE
+ string
+ default "m3.medium" if TERRAFORM_AWS_INSTANCE_M3_MEDIUM
+ default "m3.large" if TERRAFORM_AWS_INSTANCE_M3_LARGE
+ default "m3.xlarge" if TERRAFORM_AWS_INSTANCE_M3_XLARGE
+ default "m3.2xlarge" if TERRAFORM_AWS_INSTANCE_M3_2XLARGE
+ default "m3.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m4.static b/terraform/aws/kconfigs/instance-types/Kconfig.m4.static
new file mode 100644
index 00000000..f1b0937a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m4.static
@@ -0,0 +1,68 @@
+# AWS M4 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M4 family"
+ default TERRAFORM_AWS_INSTANCE_M4_LARGE
+ help
+ Select the specific instance size within the M4 family.
+
+config TERRAFORM_AWS_INSTANCE_M4_LARGE
+ bool "m4.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M4_XLARGE
+ bool "m4.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: High
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M4_2XLARGE
+ bool "m4.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: High
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M4_4XLARGE
+ bool "m4.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: High
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M4_10XLARGE
+ bool "m4.10xlarge"
+ help
+ vCPUs: 40
+ Memory: 160.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M4_16XLARGE
+ bool "m4.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M4_SIZE
+ string
+ default "m4.large" if TERRAFORM_AWS_INSTANCE_M4_LARGE
+ default "m4.xlarge" if TERRAFORM_AWS_INSTANCE_M4_XLARGE
+ default "m4.2xlarge" if TERRAFORM_AWS_INSTANCE_M4_2XLARGE
+ default "m4.4xlarge" if TERRAFORM_AWS_INSTANCE_M4_4XLARGE
+ default "m4.10xlarge" if TERRAFORM_AWS_INSTANCE_M4_10XLARGE
+ default "m4.16xlarge" if TERRAFORM_AWS_INSTANCE_M4_16XLARGE
+ default "m4.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5.static b/terraform/aws/kconfigs/instance-types/Kconfig.m5.static
new file mode 100644
index 00000000..820efdfb
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m5.static
@@ -0,0 +1,95 @@
+# AWS M5 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M5 family"
+ default TERRAFORM_AWS_INSTANCE_M5_LARGE
+ help
+ Select the specific instance size within the M5 family.
+
+config TERRAFORM_AWS_INSTANCE_M5_LARGE
+ bool "m5.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.096/hour
+
+config TERRAFORM_AWS_INSTANCE_M5_XLARGE
+ bool "m5.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.192/hour
+
+config TERRAFORM_AWS_INSTANCE_M5_2XLARGE
+ bool "m5.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.384/hour
+
+config TERRAFORM_AWS_INSTANCE_M5_4XLARGE
+ bool "m5.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: $0.768/hour
+
+config TERRAFORM_AWS_INSTANCE_M5_8XLARGE
+ bool "m5.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 10 Gigabit
+ Price: $1.536/hour
+
+config TERRAFORM_AWS_INSTANCE_M5_12XLARGE
+ bool "m5.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 12 Gigabit
+ Price: $2.304/hour
+
+config TERRAFORM_AWS_INSTANCE_M5_16XLARGE
+ bool "m5.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 20 Gigabit
+ Price: $3.072/hour
+
+config TERRAFORM_AWS_INSTANCE_M5_METAL
+ bool "m5.metal"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5_24XLARGE
+ bool "m5.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 25 Gigabit
+ Price: $4.608/hour
+
+endchoice
+
+config TERRAFORM_AWS_M5_SIZE
+ string
+ default "m5.large" if TERRAFORM_AWS_INSTANCE_M5_LARGE
+ default "m5.xlarge" if TERRAFORM_AWS_INSTANCE_M5_XLARGE
+ default "m5.2xlarge" if TERRAFORM_AWS_INSTANCE_M5_2XLARGE
+ default "m5.4xlarge" if TERRAFORM_AWS_INSTANCE_M5_4XLARGE
+ default "m5.8xlarge" if TERRAFORM_AWS_INSTANCE_M5_8XLARGE
+ default "m5.12xlarge" if TERRAFORM_AWS_INSTANCE_M5_12XLARGE
+ default "m5.16xlarge" if TERRAFORM_AWS_INSTANCE_M5_16XLARGE
+ default "m5.metal" if TERRAFORM_AWS_INSTANCE_M5_METAL
+ default "m5.24xlarge" if TERRAFORM_AWS_INSTANCE_M5_24XLARGE
+ default "m5.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5a.static b/terraform/aws/kconfigs/instance-types/Kconfig.m5a.static
new file mode 100644
index 00000000..a9b00507
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m5a.static
@@ -0,0 +1,86 @@
+# AWS M5A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M5A family"
+ default TERRAFORM_AWS_INSTANCE_M5A_LARGE
+ help
+ Select the specific instance size within the M5A family.
+
+config TERRAFORM_AWS_INSTANCE_M5A_LARGE
+ bool "m5a.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5A_XLARGE
+ bool "m5a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5A_2XLARGE
+ bool "m5a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5A_4XLARGE
+ bool "m5a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5A_8XLARGE
+ bool "m5a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5A_12XLARGE
+ bool "m5a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5A_16XLARGE
+ bool "m5a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5A_24XLARGE
+ bool "m5a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M5A_SIZE
+ string
+ default "m5a.large" if TERRAFORM_AWS_INSTANCE_M5A_LARGE
+ default "m5a.xlarge" if TERRAFORM_AWS_INSTANCE_M5A_XLARGE
+ default "m5a.2xlarge" if TERRAFORM_AWS_INSTANCE_M5A_2XLARGE
+ default "m5a.4xlarge" if TERRAFORM_AWS_INSTANCE_M5A_4XLARGE
+ default "m5a.8xlarge" if TERRAFORM_AWS_INSTANCE_M5A_8XLARGE
+ default "m5a.12xlarge" if TERRAFORM_AWS_INSTANCE_M5A_12XLARGE
+ default "m5a.16xlarge" if TERRAFORM_AWS_INSTANCE_M5A_16XLARGE
+ default "m5a.24xlarge" if TERRAFORM_AWS_INSTANCE_M5A_24XLARGE
+ default "m5a.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5ad.static b/terraform/aws/kconfigs/instance-types/Kconfig.m5ad.static
new file mode 100644
index 00000000..f2b65728
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m5ad.static
@@ -0,0 +1,94 @@
+# AWS M5AD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M5AD family"
+ default TERRAFORM_AWS_INSTANCE_M5AD_LARGE
+ help
+ Select the specific instance size within the M5AD family.
+
+config TERRAFORM_AWS_INSTANCE_M5AD_LARGE
+ bool "m5ad.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_M5AD_XLARGE
+ bool "m5ad.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_M5AD_2XLARGE
+ bool "m5ad.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_M5AD_4XLARGE
+ bool "m5ad.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_M5AD_8XLARGE
+ bool "m5ad.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_M5AD_12XLARGE
+ bool "m5ad.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_M5AD_16XLARGE
+ bool "m5ad.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+config TERRAFORM_AWS_INSTANCE_M5AD_24XLARGE
+ bool "m5ad.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+endchoice
+
+config TERRAFORM_AWS_M5AD_SIZE
+ string
+ default "m5ad.large" if TERRAFORM_AWS_INSTANCE_M5AD_LARGE
+ default "m5ad.xlarge" if TERRAFORM_AWS_INSTANCE_M5AD_XLARGE
+ default "m5ad.2xlarge" if TERRAFORM_AWS_INSTANCE_M5AD_2XLARGE
+ default "m5ad.4xlarge" if TERRAFORM_AWS_INSTANCE_M5AD_4XLARGE
+ default "m5ad.8xlarge" if TERRAFORM_AWS_INSTANCE_M5AD_8XLARGE
+ default "m5ad.12xlarge" if TERRAFORM_AWS_INSTANCE_M5AD_12XLARGE
+ default "m5ad.16xlarge" if TERRAFORM_AWS_INSTANCE_M5AD_16XLARGE
+ default "m5ad.24xlarge" if TERRAFORM_AWS_INSTANCE_M5AD_24XLARGE
+ default "m5ad.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5d.static b/terraform/aws/kconfigs/instance-types/Kconfig.m5d.static
new file mode 100644
index 00000000..3e28baac
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m5d.static
@@ -0,0 +1,104 @@
+# AWS M5D instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M5D family"
+ default TERRAFORM_AWS_INSTANCE_M5D_LARGE
+ help
+ Select the specific instance size within the M5D family.
+
+config TERRAFORM_AWS_INSTANCE_M5D_LARGE
+ bool "m5d.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_XLARGE
+ bool "m5d.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_2XLARGE
+ bool "m5d.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_4XLARGE
+ bool "m5d.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_8XLARGE
+ bool "m5d.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_12XLARGE
+ bool "m5d.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_16XLARGE
+ bool "m5d.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_METAL
+ bool "m5d.metal"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+config TERRAFORM_AWS_INSTANCE_M5D_24XLARGE
+ bool "m5d.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+endchoice
+
+config TERRAFORM_AWS_M5D_SIZE
+ string
+ default "m5d.large" if TERRAFORM_AWS_INSTANCE_M5D_LARGE
+ default "m5d.xlarge" if TERRAFORM_AWS_INSTANCE_M5D_XLARGE
+ default "m5d.2xlarge" if TERRAFORM_AWS_INSTANCE_M5D_2XLARGE
+ default "m5d.4xlarge" if TERRAFORM_AWS_INSTANCE_M5D_4XLARGE
+ default "m5d.8xlarge" if TERRAFORM_AWS_INSTANCE_M5D_8XLARGE
+ default "m5d.12xlarge" if TERRAFORM_AWS_INSTANCE_M5D_12XLARGE
+ default "m5d.16xlarge" if TERRAFORM_AWS_INSTANCE_M5D_16XLARGE
+ default "m5d.metal" if TERRAFORM_AWS_INSTANCE_M5D_METAL
+ default "m5d.24xlarge" if TERRAFORM_AWS_INSTANCE_M5D_24XLARGE
+ default "m5d.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5dn.static b/terraform/aws/kconfigs/instance-types/Kconfig.m5dn.static
new file mode 100644
index 00000000..14e55cf0
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m5dn.static
@@ -0,0 +1,104 @@
+# AWS M5DN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M5DN family"
+ default TERRAFORM_AWS_INSTANCE_M5DN_LARGE
+ help
+ Select the specific instance size within the M5DN family.
+
+config TERRAFORM_AWS_INSTANCE_M5DN_LARGE
+ bool "m5dn.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_XLARGE
+ bool "m5dn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_2XLARGE
+ bool "m5dn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_4XLARGE
+ bool "m5dn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_8XLARGE
+ bool "m5dn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_12XLARGE
+ bool "m5dn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_16XLARGE
+ bool "m5dn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_METAL
+ bool "m5dn.metal"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+config TERRAFORM_AWS_INSTANCE_M5DN_24XLARGE
+ bool "m5dn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+endchoice
+
+config TERRAFORM_AWS_M5DN_SIZE
+ string
+ default "m5dn.large" if TERRAFORM_AWS_INSTANCE_M5DN_LARGE
+ default "m5dn.xlarge" if TERRAFORM_AWS_INSTANCE_M5DN_XLARGE
+ default "m5dn.2xlarge" if TERRAFORM_AWS_INSTANCE_M5DN_2XLARGE
+ default "m5dn.4xlarge" if TERRAFORM_AWS_INSTANCE_M5DN_4XLARGE
+ default "m5dn.8xlarge" if TERRAFORM_AWS_INSTANCE_M5DN_8XLARGE
+ default "m5dn.12xlarge" if TERRAFORM_AWS_INSTANCE_M5DN_12XLARGE
+ default "m5dn.16xlarge" if TERRAFORM_AWS_INSTANCE_M5DN_16XLARGE
+ default "m5dn.metal" if TERRAFORM_AWS_INSTANCE_M5DN_METAL
+ default "m5dn.24xlarge" if TERRAFORM_AWS_INSTANCE_M5DN_24XLARGE
+ default "m5dn.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5n.static b/terraform/aws/kconfigs/instance-types/Kconfig.m5n.static
new file mode 100644
index 00000000..2887e84e
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m5n.static
@@ -0,0 +1,95 @@
+# AWS M5N instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M5N family"
+ default TERRAFORM_AWS_INSTANCE_M5N_LARGE
+ help
+ Select the specific instance size within the M5N family.
+
+config TERRAFORM_AWS_INSTANCE_M5N_LARGE
+ bool "m5n.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_XLARGE
+ bool "m5n.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_2XLARGE
+ bool "m5n.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_4XLARGE
+ bool "m5n.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_8XLARGE
+ bool "m5n.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_12XLARGE
+ bool "m5n.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_16XLARGE
+ bool "m5n.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_METAL
+ bool "m5n.metal"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5N_24XLARGE
+ bool "m5n.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M5N_SIZE
+ string
+ default "m5n.large" if TERRAFORM_AWS_INSTANCE_M5N_LARGE
+ default "m5n.xlarge" if TERRAFORM_AWS_INSTANCE_M5N_XLARGE
+ default "m5n.2xlarge" if TERRAFORM_AWS_INSTANCE_M5N_2XLARGE
+ default "m5n.4xlarge" if TERRAFORM_AWS_INSTANCE_M5N_4XLARGE
+ default "m5n.8xlarge" if TERRAFORM_AWS_INSTANCE_M5N_8XLARGE
+ default "m5n.12xlarge" if TERRAFORM_AWS_INSTANCE_M5N_12XLARGE
+ default "m5n.16xlarge" if TERRAFORM_AWS_INSTANCE_M5N_16XLARGE
+ default "m5n.metal" if TERRAFORM_AWS_INSTANCE_M5N_METAL
+ default "m5n.24xlarge" if TERRAFORM_AWS_INSTANCE_M5N_24XLARGE
+ default "m5n.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m5zn.static b/terraform/aws/kconfigs/instance-types/Kconfig.m5zn.static
new file mode 100644
index 00000000..849640b7
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m5zn.static
@@ -0,0 +1,77 @@
+# AWS M5ZN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M5ZN family"
+ default TERRAFORM_AWS_INSTANCE_M5ZN_LARGE
+ help
+ Select the specific instance size within the M5ZN family.
+
+config TERRAFORM_AWS_INSTANCE_M5ZN_LARGE
+ bool "m5zn.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5ZN_XLARGE
+ bool "m5zn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5ZN_2XLARGE
+ bool "m5zn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5ZN_3XLARGE
+ bool "m5zn.3xlarge"
+ help
+ vCPUs: 12
+ Memory: 48.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5ZN_6XLARGE
+ bool "m5zn.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 96.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5ZN_12XLARGE
+ bool "m5zn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M5ZN_METAL
+ bool "m5zn.metal"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M5ZN_SIZE
+ string
+ default "m5zn.large" if TERRAFORM_AWS_INSTANCE_M5ZN_LARGE
+ default "m5zn.xlarge" if TERRAFORM_AWS_INSTANCE_M5ZN_XLARGE
+ default "m5zn.2xlarge" if TERRAFORM_AWS_INSTANCE_M5ZN_2XLARGE
+ default "m5zn.3xlarge" if TERRAFORM_AWS_INSTANCE_M5ZN_3XLARGE
+ default "m5zn.6xlarge" if TERRAFORM_AWS_INSTANCE_M5ZN_6XLARGE
+ default "m5zn.12xlarge" if TERRAFORM_AWS_INSTANCE_M5ZN_12XLARGE
+ default "m5zn.metal" if TERRAFORM_AWS_INSTANCE_M5ZN_METAL
+ default "m5zn.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m6a.static b/terraform/aws/kconfigs/instance-types/Kconfig.m6a.static
new file mode 100644
index 00000000..e7de066a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m6a.static
@@ -0,0 +1,113 @@
+# AWS M6A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M6A family"
+ default TERRAFORM_AWS_INSTANCE_M6A_LARGE
+ help
+ Select the specific instance size within the M6A family.
+
+config TERRAFORM_AWS_INSTANCE_M6A_LARGE
+ bool "m6a.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_XLARGE
+ bool "m6a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_2XLARGE
+ bool "m6a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_4XLARGE
+ bool "m6a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_8XLARGE
+ bool "m6a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_12XLARGE
+ bool "m6a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_16XLARGE
+ bool "m6a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_24XLARGE
+ bool "m6a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_32XLARGE
+ bool "m6a.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_METAL
+ bool "m6a.metal"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6A_48XLARGE
+ bool "m6a.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M6A_SIZE
+ string
+ default "m6a.large" if TERRAFORM_AWS_INSTANCE_M6A_LARGE
+ default "m6a.xlarge" if TERRAFORM_AWS_INSTANCE_M6A_XLARGE
+ default "m6a.2xlarge" if TERRAFORM_AWS_INSTANCE_M6A_2XLARGE
+ default "m6a.4xlarge" if TERRAFORM_AWS_INSTANCE_M6A_4XLARGE
+ default "m6a.8xlarge" if TERRAFORM_AWS_INSTANCE_M6A_8XLARGE
+ default "m6a.12xlarge" if TERRAFORM_AWS_INSTANCE_M6A_12XLARGE
+ default "m6a.16xlarge" if TERRAFORM_AWS_INSTANCE_M6A_16XLARGE
+ default "m6a.24xlarge" if TERRAFORM_AWS_INSTANCE_M6A_24XLARGE
+ default "m6a.32xlarge" if TERRAFORM_AWS_INSTANCE_M6A_32XLARGE
+ default "m6a.metal" if TERRAFORM_AWS_INSTANCE_M6A_METAL
+ default "m6a.48xlarge" if TERRAFORM_AWS_INSTANCE_M6A_48XLARGE
+ default "m6a.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m6g.static b/terraform/aws/kconfigs/instance-types/Kconfig.m6g.static
new file mode 100644
index 00000000..dc3b8c4b
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m6g.static
@@ -0,0 +1,95 @@
+# AWS M6G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M6G family"
+ default TERRAFORM_AWS_INSTANCE_M6G_MEDIUM
+ help
+ Select the specific instance size within the M6G family.
+
+config TERRAFORM_AWS_INSTANCE_M6G_MEDIUM
+ bool "m6g.medium"
+ help
+ vCPUs: 1
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_LARGE
+ bool "m6g.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_XLARGE
+ bool "m6g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_2XLARGE
+ bool "m6g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_4XLARGE
+ bool "m6g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_8XLARGE
+ bool "m6g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_12XLARGE
+ bool "m6g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_METAL
+ bool "m6g.metal"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6G_16XLARGE
+ bool "m6g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M6G_SIZE
+ string
+ default "m6g.medium" if TERRAFORM_AWS_INSTANCE_M6G_MEDIUM
+ default "m6g.large" if TERRAFORM_AWS_INSTANCE_M6G_LARGE
+ default "m6g.xlarge" if TERRAFORM_AWS_INSTANCE_M6G_XLARGE
+ default "m6g.2xlarge" if TERRAFORM_AWS_INSTANCE_M6G_2XLARGE
+ default "m6g.4xlarge" if TERRAFORM_AWS_INSTANCE_M6G_4XLARGE
+ default "m6g.8xlarge" if TERRAFORM_AWS_INSTANCE_M6G_8XLARGE
+ default "m6g.12xlarge" if TERRAFORM_AWS_INSTANCE_M6G_12XLARGE
+ default "m6g.metal" if TERRAFORM_AWS_INSTANCE_M6G_METAL
+ default "m6g.16xlarge" if TERRAFORM_AWS_INSTANCE_M6G_16XLARGE
+ default "m6g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m6gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.m6gd.static
new file mode 100644
index 00000000..439c5d82
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m6gd.static
@@ -0,0 +1,104 @@
+# AWS M6GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M6GD family"
+ default TERRAFORM_AWS_INSTANCE_M6GD_MEDIUM
+ help
+ Select the specific instance size within the M6GD family.
+
+config TERRAFORM_AWS_INSTANCE_M6GD_MEDIUM
+ bool "m6gd.medium"
+ help
+ vCPUs: 1
+ Memory: 4.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_LARGE
+ bool "m6gd.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_XLARGE
+ bool "m6gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_2XLARGE
+ bool "m6gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_4XLARGE
+ bool "m6gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_8XLARGE
+ bool "m6gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_12XLARGE
+ bool "m6gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_METAL
+ bool "m6gd.metal"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_M6GD_16XLARGE
+ bool "m6gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_M6GD_SIZE
+ string
+ default "m6gd.medium" if TERRAFORM_AWS_INSTANCE_M6GD_MEDIUM
+ default "m6gd.large" if TERRAFORM_AWS_INSTANCE_M6GD_LARGE
+ default "m6gd.xlarge" if TERRAFORM_AWS_INSTANCE_M6GD_XLARGE
+ default "m6gd.2xlarge" if TERRAFORM_AWS_INSTANCE_M6GD_2XLARGE
+ default "m6gd.4xlarge" if TERRAFORM_AWS_INSTANCE_M6GD_4XLARGE
+ default "m6gd.8xlarge" if TERRAFORM_AWS_INSTANCE_M6GD_8XLARGE
+ default "m6gd.12xlarge" if TERRAFORM_AWS_INSTANCE_M6GD_12XLARGE
+ default "m6gd.metal" if TERRAFORM_AWS_INSTANCE_M6GD_METAL
+ default "m6gd.16xlarge" if TERRAFORM_AWS_INSTANCE_M6GD_16XLARGE
+ default "m6gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m6i.static b/terraform/aws/kconfigs/instance-types/Kconfig.m6i.static
new file mode 100644
index 00000000..69fd07b9
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m6i.static
@@ -0,0 +1,104 @@
+# AWS M6I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M6I family"
+ default TERRAFORM_AWS_INSTANCE_M6I_LARGE
+ help
+ Select the specific instance size within the M6I family.
+
+config TERRAFORM_AWS_INSTANCE_M6I_LARGE
+ bool "m6i.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_XLARGE
+ bool "m6i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_2XLARGE
+ bool "m6i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_4XLARGE
+ bool "m6i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_8XLARGE
+ bool "m6i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_12XLARGE
+ bool "m6i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_16XLARGE
+ bool "m6i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_24XLARGE
+ bool "m6i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_METAL
+ bool "m6i.metal"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6I_32XLARGE
+ bool "m6i.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M6I_SIZE
+ string
+ default "m6i.large" if TERRAFORM_AWS_INSTANCE_M6I_LARGE
+ default "m6i.xlarge" if TERRAFORM_AWS_INSTANCE_M6I_XLARGE
+ default "m6i.2xlarge" if TERRAFORM_AWS_INSTANCE_M6I_2XLARGE
+ default "m6i.4xlarge" if TERRAFORM_AWS_INSTANCE_M6I_4XLARGE
+ default "m6i.8xlarge" if TERRAFORM_AWS_INSTANCE_M6I_8XLARGE
+ default "m6i.12xlarge" if TERRAFORM_AWS_INSTANCE_M6I_12XLARGE
+ default "m6i.16xlarge" if TERRAFORM_AWS_INSTANCE_M6I_16XLARGE
+ default "m6i.24xlarge" if TERRAFORM_AWS_INSTANCE_M6I_24XLARGE
+ default "m6i.metal" if TERRAFORM_AWS_INSTANCE_M6I_METAL
+ default "m6i.32xlarge" if TERRAFORM_AWS_INSTANCE_M6I_32XLARGE
+ default "m6i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m6id.static b/terraform/aws/kconfigs/instance-types/Kconfig.m6id.static
new file mode 100644
index 00000000..e3300228
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m6id.static
@@ -0,0 +1,114 @@
+# AWS M6ID instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M6ID family"
+ default TERRAFORM_AWS_INSTANCE_M6ID_LARGE
+ help
+ Select the specific instance size within the M6ID family.
+
+config TERRAFORM_AWS_INSTANCE_M6ID_LARGE
+ bool "m6id.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_XLARGE
+ bool "m6id.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_2XLARGE
+ bool "m6id.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_4XLARGE
+ bool "m6id.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_8XLARGE
+ bool "m6id.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_12XLARGE
+ bool "m6id.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_16XLARGE
+ bool "m6id.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_24XLARGE
+ bool "m6id.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_32XLARGE
+ bool "m6id.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+config TERRAFORM_AWS_INSTANCE_M6ID_METAL
+ bool "m6id.metal"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_M6ID_SIZE
+ string
+ default "m6id.large" if TERRAFORM_AWS_INSTANCE_M6ID_LARGE
+ default "m6id.xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_XLARGE
+ default "m6id.2xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_2XLARGE
+ default "m6id.4xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_4XLARGE
+ default "m6id.8xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_8XLARGE
+ default "m6id.12xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_12XLARGE
+ default "m6id.16xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_16XLARGE
+ default "m6id.24xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_24XLARGE
+ default "m6id.32xlarge" if TERRAFORM_AWS_INSTANCE_M6ID_32XLARGE
+ default "m6id.metal" if TERRAFORM_AWS_INSTANCE_M6ID_METAL
+ default "m6id.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m6idn.static b/terraform/aws/kconfigs/instance-types/Kconfig.m6idn.static
new file mode 100644
index 00000000..e979aecd
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m6idn.static
@@ -0,0 +1,114 @@
+# AWS M6IDN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M6IDN family"
+ default TERRAFORM_AWS_INSTANCE_M6IDN_LARGE
+ help
+ Select the specific instance size within the M6IDN family.
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_LARGE
+ bool "m6idn.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_XLARGE
+ bool "m6idn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_2XLARGE
+ bool "m6idn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 40 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_4XLARGE
+ bool "m6idn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_8XLARGE
+ bool "m6idn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_12XLARGE
+ bool "m6idn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_16XLARGE
+ bool "m6idn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_24XLARGE
+ bool "m6idn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_32XLARGE
+ bool "m6idn.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+config TERRAFORM_AWS_INSTANCE_M6IDN_METAL
+ bool "m6idn.metal"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_M6IDN_SIZE
+ string
+ default "m6idn.large" if TERRAFORM_AWS_INSTANCE_M6IDN_LARGE
+ default "m6idn.xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_XLARGE
+ default "m6idn.2xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_2XLARGE
+ default "m6idn.4xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_4XLARGE
+ default "m6idn.8xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_8XLARGE
+ default "m6idn.12xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_12XLARGE
+ default "m6idn.16xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_16XLARGE
+ default "m6idn.24xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_24XLARGE
+ default "m6idn.32xlarge" if TERRAFORM_AWS_INSTANCE_M6IDN_32XLARGE
+ default "m6idn.metal" if TERRAFORM_AWS_INSTANCE_M6IDN_METAL
+ default "m6idn.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m6in.static b/terraform/aws/kconfigs/instance-types/Kconfig.m6in.static
new file mode 100644
index 00000000..c96ee774
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m6in.static
@@ -0,0 +1,104 @@
+# AWS M6IN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M6IN family"
+ default TERRAFORM_AWS_INSTANCE_M6IN_LARGE
+ help
+ Select the specific instance size within the M6IN family.
+
+config TERRAFORM_AWS_INSTANCE_M6IN_LARGE
+ bool "m6in.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_XLARGE
+ bool "m6in.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_2XLARGE
+ bool "m6in.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_4XLARGE
+ bool "m6in.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_8XLARGE
+ bool "m6in.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_12XLARGE
+ bool "m6in.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_16XLARGE
+ bool "m6in.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_24XLARGE
+ bool "m6in.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_32XLARGE
+ bool "m6in.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M6IN_METAL
+ bool "m6in.metal"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M6IN_SIZE
+ string
+ default "m6in.large" if TERRAFORM_AWS_INSTANCE_M6IN_LARGE
+ default "m6in.xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_XLARGE
+ default "m6in.2xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_2XLARGE
+ default "m6in.4xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_4XLARGE
+ default "m6in.8xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_8XLARGE
+ default "m6in.12xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_12XLARGE
+ default "m6in.16xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_16XLARGE
+ default "m6in.24xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_24XLARGE
+ default "m6in.32xlarge" if TERRAFORM_AWS_INSTANCE_M6IN_32XLARGE
+ default "m6in.metal" if TERRAFORM_AWS_INSTANCE_M6IN_METAL
+ default "m6in.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m7a.static b/terraform/aws/kconfigs/instance-types/Kconfig.m7a.static
new file mode 100644
index 00000000..8e3940fb
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m7a.static
@@ -0,0 +1,122 @@
+# AWS M7A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M7A family"
+ default TERRAFORM_AWS_INSTANCE_M7A_MEDIUM
+ help
+ Select the specific instance size within the M7A family.
+
+config TERRAFORM_AWS_INSTANCE_M7A_MEDIUM
+ bool "m7a.medium"
+ help
+ vCPUs: 1
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.046/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_LARGE
+ bool "m7a.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.093/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_XLARGE
+ bool "m7a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.186/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_2XLARGE
+ bool "m7a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.371/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_4XLARGE
+ bool "m7a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: $0.742/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_8XLARGE
+ bool "m7a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 12.5 Gigabit
+ Price: $1.485/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_12XLARGE
+ bool "m7a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 18.75 Gigabit
+ Price: $2.227/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_16XLARGE
+ bool "m7a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: $2.970/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_24XLARGE
+ bool "m7a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 37.5 Gigabit
+ Price: $4.454/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_32XLARGE
+ bool "m7a.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 50 Gigabit
+ Price: $5.939/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_48XLARGE
+ bool "m7a.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: $8.909/hour
+
+config TERRAFORM_AWS_INSTANCE_M7A_METAL_48XL
+ bool "m7a.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M7A_SIZE
+ string
+ default "m7a.medium" if TERRAFORM_AWS_INSTANCE_M7A_MEDIUM
+ default "m7a.large" if TERRAFORM_AWS_INSTANCE_M7A_LARGE
+ default "m7a.xlarge" if TERRAFORM_AWS_INSTANCE_M7A_XLARGE
+ default "m7a.2xlarge" if TERRAFORM_AWS_INSTANCE_M7A_2XLARGE
+ default "m7a.4xlarge" if TERRAFORM_AWS_INSTANCE_M7A_4XLARGE
+ default "m7a.8xlarge" if TERRAFORM_AWS_INSTANCE_M7A_8XLARGE
+ default "m7a.12xlarge" if TERRAFORM_AWS_INSTANCE_M7A_12XLARGE
+ default "m7a.16xlarge" if TERRAFORM_AWS_INSTANCE_M7A_16XLARGE
+ default "m7a.24xlarge" if TERRAFORM_AWS_INSTANCE_M7A_24XLARGE
+ default "m7a.32xlarge" if TERRAFORM_AWS_INSTANCE_M7A_32XLARGE
+ default "m7a.48xlarge" if TERRAFORM_AWS_INSTANCE_M7A_48XLARGE
+ default "m7a.metal-48xl" if TERRAFORM_AWS_INSTANCE_M7A_METAL_48XL
+ default "m7a.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m7g.static b/terraform/aws/kconfigs/instance-types/Kconfig.m7g.static
new file mode 100644
index 00000000..9fde97d5
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m7g.static
@@ -0,0 +1,95 @@
+# AWS M7G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M7G family"
+ default TERRAFORM_AWS_INSTANCE_M7G_MEDIUM
+ help
+ Select the specific instance size within the M7G family.
+
+config TERRAFORM_AWS_INSTANCE_M7G_MEDIUM
+ bool "m7g.medium"
+ help
+ vCPUs: 1
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_LARGE
+ bool "m7g.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_XLARGE
+ bool "m7g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_2XLARGE
+ bool "m7g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_4XLARGE
+ bool "m7g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_8XLARGE
+ bool "m7g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_12XLARGE
+ bool "m7g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_16XLARGE
+ bool "m7g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7G_METAL
+ bool "m7g.metal"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M7G_SIZE
+ string
+ default "m7g.medium" if TERRAFORM_AWS_INSTANCE_M7G_MEDIUM
+ default "m7g.large" if TERRAFORM_AWS_INSTANCE_M7G_LARGE
+ default "m7g.xlarge" if TERRAFORM_AWS_INSTANCE_M7G_XLARGE
+ default "m7g.2xlarge" if TERRAFORM_AWS_INSTANCE_M7G_2XLARGE
+ default "m7g.4xlarge" if TERRAFORM_AWS_INSTANCE_M7G_4XLARGE
+ default "m7g.8xlarge" if TERRAFORM_AWS_INSTANCE_M7G_8XLARGE
+ default "m7g.12xlarge" if TERRAFORM_AWS_INSTANCE_M7G_12XLARGE
+ default "m7g.16xlarge" if TERRAFORM_AWS_INSTANCE_M7G_16XLARGE
+ default "m7g.metal" if TERRAFORM_AWS_INSTANCE_M7G_METAL
+ default "m7g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m7gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.m7gd.static
new file mode 100644
index 00000000..42b514a0
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m7gd.static
@@ -0,0 +1,104 @@
+# AWS M7GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M7GD family"
+ default TERRAFORM_AWS_INSTANCE_M7GD_MEDIUM
+ help
+ Select the specific instance size within the M7GD family.
+
+config TERRAFORM_AWS_INSTANCE_M7GD_MEDIUM
+ bool "m7gd.medium"
+ help
+ vCPUs: 1
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_LARGE
+ bool "m7gd.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_XLARGE
+ bool "m7gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_2XLARGE
+ bool "m7gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_4XLARGE
+ bool "m7gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_8XLARGE
+ bool "m7gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_12XLARGE
+ bool "m7gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_16XLARGE
+ bool "m7gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_M7GD_METAL
+ bool "m7gd.metal"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_M7GD_SIZE
+ string
+ default "m7gd.medium" if TERRAFORM_AWS_INSTANCE_M7GD_MEDIUM
+ default "m7gd.large" if TERRAFORM_AWS_INSTANCE_M7GD_LARGE
+ default "m7gd.xlarge" if TERRAFORM_AWS_INSTANCE_M7GD_XLARGE
+ default "m7gd.2xlarge" if TERRAFORM_AWS_INSTANCE_M7GD_2XLARGE
+ default "m7gd.4xlarge" if TERRAFORM_AWS_INSTANCE_M7GD_4XLARGE
+ default "m7gd.8xlarge" if TERRAFORM_AWS_INSTANCE_M7GD_8XLARGE
+ default "m7gd.12xlarge" if TERRAFORM_AWS_INSTANCE_M7GD_12XLARGE
+ default "m7gd.16xlarge" if TERRAFORM_AWS_INSTANCE_M7GD_16XLARGE
+ default "m7gd.metal" if TERRAFORM_AWS_INSTANCE_M7GD_METAL
+ default "m7gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m7i-flex.static b/terraform/aws/kconfigs/instance-types/Kconfig.m7i-flex.static
new file mode 100644
index 00000000..1eaf64b3
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m7i-flex.static
@@ -0,0 +1,77 @@
+# AWS M7I-FLEX instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M7I-FLEX family"
+ default TERRAFORM_AWS_INSTANCE_M7I_FLEX_LARGE
+ help
+ Select the specific instance size within the M7I-FLEX family.
+
+config TERRAFORM_AWS_INSTANCE_M7I_FLEX_LARGE
+ bool "m7i-flex.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_FLEX_XLARGE
+ bool "m7i-flex.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_FLEX_2XLARGE
+ bool "m7i-flex.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_FLEX_4XLARGE
+ bool "m7i-flex.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_FLEX_8XLARGE
+ bool "m7i-flex.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_FLEX_12XLARGE
+ bool "m7i-flex.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: Up to 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_FLEX_16XLARGE
+ bool "m7i-flex.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M7I_FLEX_SIZE
+ string
+ default "m7i-flex.large" if TERRAFORM_AWS_INSTANCE_M7I_FLEX_LARGE
+ default "m7i-flex.xlarge" if TERRAFORM_AWS_INSTANCE_M7I_FLEX_XLARGE
+ default "m7i-flex.2xlarge" if TERRAFORM_AWS_INSTANCE_M7I_FLEX_2XLARGE
+ default "m7i-flex.4xlarge" if TERRAFORM_AWS_INSTANCE_M7I_FLEX_4XLARGE
+ default "m7i-flex.8xlarge" if TERRAFORM_AWS_INSTANCE_M7I_FLEX_8XLARGE
+ default "m7i-flex.12xlarge" if TERRAFORM_AWS_INSTANCE_M7I_FLEX_12XLARGE
+ default "m7i-flex.16xlarge" if TERRAFORM_AWS_INSTANCE_M7I_FLEX_16XLARGE
+ default "m7i-flex.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m7i.static b/terraform/aws/kconfigs/instance-types/Kconfig.m7i.static
new file mode 100644
index 00000000..322fa33d
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m7i.static
@@ -0,0 +1,113 @@
+# AWS M7I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M7I family"
+ default TERRAFORM_AWS_INSTANCE_M7I_LARGE
+ help
+ Select the specific instance size within the M7I family.
+
+config TERRAFORM_AWS_INSTANCE_M7I_LARGE
+ bool "m7i.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_XLARGE
+ bool "m7i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_2XLARGE
+ bool "m7i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_4XLARGE
+ bool "m7i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_8XLARGE
+ bool "m7i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_12XLARGE
+ bool "m7i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_16XLARGE
+ bool "m7i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_METAL_24XL
+ bool "m7i.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_24XLARGE
+ bool "m7i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_48XLARGE
+ bool "m7i.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M7I_METAL_48XL
+ bool "m7i.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M7I_SIZE
+ string
+ default "m7i.large" if TERRAFORM_AWS_INSTANCE_M7I_LARGE
+ default "m7i.xlarge" if TERRAFORM_AWS_INSTANCE_M7I_XLARGE
+ default "m7i.2xlarge" if TERRAFORM_AWS_INSTANCE_M7I_2XLARGE
+ default "m7i.4xlarge" if TERRAFORM_AWS_INSTANCE_M7I_4XLARGE
+ default "m7i.8xlarge" if TERRAFORM_AWS_INSTANCE_M7I_8XLARGE
+ default "m7i.12xlarge" if TERRAFORM_AWS_INSTANCE_M7I_12XLARGE
+ default "m7i.16xlarge" if TERRAFORM_AWS_INSTANCE_M7I_16XLARGE
+ default "m7i.metal-24xl" if TERRAFORM_AWS_INSTANCE_M7I_METAL_24XL
+ default "m7i.24xlarge" if TERRAFORM_AWS_INSTANCE_M7I_24XLARGE
+ default "m7i.48xlarge" if TERRAFORM_AWS_INSTANCE_M7I_48XLARGE
+ default "m7i.metal-48xl" if TERRAFORM_AWS_INSTANCE_M7I_METAL_48XL
+ default "m7i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m8g.static b/terraform/aws/kconfigs/instance-types/Kconfig.m8g.static
new file mode 100644
index 00000000..c15cc7dd
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m8g.static
@@ -0,0 +1,122 @@
+# AWS M8G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M8G family"
+ default TERRAFORM_AWS_INSTANCE_M8G_MEDIUM
+ help
+ Select the specific instance size within the M8G family.
+
+config TERRAFORM_AWS_INSTANCE_M8G_MEDIUM
+ bool "m8g.medium"
+ help
+ vCPUs: 1
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_LARGE
+ bool "m8g.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_XLARGE
+ bool "m8g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_2XLARGE
+ bool "m8g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_4XLARGE
+ bool "m8g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_8XLARGE
+ bool "m8g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_12XLARGE
+ bool "m8g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_16XLARGE
+ bool "m8g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_24XLARGE
+ bool "m8g.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_METAL_24XL
+ bool "m8g.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_METAL_48XL
+ bool "m8g.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8G_48XLARGE
+ bool "m8g.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M8G_SIZE
+ string
+ default "m8g.medium" if TERRAFORM_AWS_INSTANCE_M8G_MEDIUM
+ default "m8g.large" if TERRAFORM_AWS_INSTANCE_M8G_LARGE
+ default "m8g.xlarge" if TERRAFORM_AWS_INSTANCE_M8G_XLARGE
+ default "m8g.2xlarge" if TERRAFORM_AWS_INSTANCE_M8G_2XLARGE
+ default "m8g.4xlarge" if TERRAFORM_AWS_INSTANCE_M8G_4XLARGE
+ default "m8g.8xlarge" if TERRAFORM_AWS_INSTANCE_M8G_8XLARGE
+ default "m8g.12xlarge" if TERRAFORM_AWS_INSTANCE_M8G_12XLARGE
+ default "m8g.16xlarge" if TERRAFORM_AWS_INSTANCE_M8G_16XLARGE
+ default "m8g.24xlarge" if TERRAFORM_AWS_INSTANCE_M8G_24XLARGE
+ default "m8g.metal-24xl" if TERRAFORM_AWS_INSTANCE_M8G_METAL_24XL
+ default "m8g.metal-48xl" if TERRAFORM_AWS_INSTANCE_M8G_METAL_48XL
+ default "m8g.48xlarge" if TERRAFORM_AWS_INSTANCE_M8G_48XLARGE
+ default "m8g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m8gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.m8gd.static
new file mode 100644
index 00000000..ffc1ed87
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m8gd.static
@@ -0,0 +1,134 @@
+# AWS M8GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M8GD family"
+ default TERRAFORM_AWS_INSTANCE_M8GD_MEDIUM
+ help
+ Select the specific instance size within the M8GD family.
+
+config TERRAFORM_AWS_INSTANCE_M8GD_MEDIUM
+ bool "m8gd.medium"
+ help
+ vCPUs: 1
+ Memory: 4.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_LARGE
+ bool "m8gd.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_XLARGE
+ bool "m8gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_2XLARGE
+ bool "m8gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_4XLARGE
+ bool "m8gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_8XLARGE
+ bool "m8gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_12XLARGE
+ bool "m8gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_16XLARGE
+ bool "m8gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_24XLARGE
+ bool "m8gd.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_METAL_24XL
+ bool "m8gd.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_METAL_48XL
+ bool "m8gd.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 11400 GB
+
+config TERRAFORM_AWS_INSTANCE_M8GD_48XLARGE
+ bool "m8gd.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 11400 GB
+
+endchoice
+
+config TERRAFORM_AWS_M8GD_SIZE
+ string
+ default "m8gd.medium" if TERRAFORM_AWS_INSTANCE_M8GD_MEDIUM
+ default "m8gd.large" if TERRAFORM_AWS_INSTANCE_M8GD_LARGE
+ default "m8gd.xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_XLARGE
+ default "m8gd.2xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_2XLARGE
+ default "m8gd.4xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_4XLARGE
+ default "m8gd.8xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_8XLARGE
+ default "m8gd.12xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_12XLARGE
+ default "m8gd.16xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_16XLARGE
+ default "m8gd.24xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_24XLARGE
+ default "m8gd.metal-24xl" if TERRAFORM_AWS_INSTANCE_M8GD_METAL_24XL
+ default "m8gd.metal-48xl" if TERRAFORM_AWS_INSTANCE_M8GD_METAL_48XL
+ default "m8gd.48xlarge" if TERRAFORM_AWS_INSTANCE_M8GD_48XLARGE
+ default "m8gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m8i-flex.static b/terraform/aws/kconfigs/instance-types/Kconfig.m8i-flex.static
new file mode 100644
index 00000000..655e3d19
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m8i-flex.static
@@ -0,0 +1,77 @@
+# AWS M8I-FLEX instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M8I-FLEX family"
+ default TERRAFORM_AWS_INSTANCE_M8I_FLEX_LARGE
+ help
+ Select the specific instance size within the M8I-FLEX family.
+
+config TERRAFORM_AWS_INSTANCE_M8I_FLEX_LARGE
+ bool "m8i-flex.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_FLEX_XLARGE
+ bool "m8i-flex.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_FLEX_2XLARGE
+ bool "m8i-flex.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_FLEX_4XLARGE
+ bool "m8i-flex.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_FLEX_8XLARGE
+ bool "m8i-flex.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_FLEX_12XLARGE
+ bool "m8i-flex.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: Up to 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_FLEX_16XLARGE
+ bool "m8i-flex.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M8I_FLEX_SIZE
+ string
+ default "m8i-flex.large" if TERRAFORM_AWS_INSTANCE_M8I_FLEX_LARGE
+ default "m8i-flex.xlarge" if TERRAFORM_AWS_INSTANCE_M8I_FLEX_XLARGE
+ default "m8i-flex.2xlarge" if TERRAFORM_AWS_INSTANCE_M8I_FLEX_2XLARGE
+ default "m8i-flex.4xlarge" if TERRAFORM_AWS_INSTANCE_M8I_FLEX_4XLARGE
+ default "m8i-flex.8xlarge" if TERRAFORM_AWS_INSTANCE_M8I_FLEX_8XLARGE
+ default "m8i-flex.12xlarge" if TERRAFORM_AWS_INSTANCE_M8I_FLEX_12XLARGE
+ default "m8i-flex.16xlarge" if TERRAFORM_AWS_INSTANCE_M8I_FLEX_16XLARGE
+ default "m8i-flex.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.m8i.static b/terraform/aws/kconfigs/instance-types/Kconfig.m8i.static
new file mode 100644
index 00000000..964f90ee
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.m8i.static
@@ -0,0 +1,131 @@
+# AWS M8I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for M8I family"
+ default TERRAFORM_AWS_INSTANCE_M8I_LARGE
+ help
+ Select the specific instance size within the M8I family.
+
+config TERRAFORM_AWS_INSTANCE_M8I_LARGE
+ bool "m8i.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_XLARGE
+ bool "m8i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_2XLARGE
+ bool "m8i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_4XLARGE
+ bool "m8i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_8XLARGE
+ bool "m8i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 128.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_12XLARGE
+ bool "m8i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 192.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_16XLARGE
+ bool "m8i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 256.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_24XLARGE
+ bool "m8i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 384.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_32XLARGE
+ bool "m8i.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_48XLARGE
+ bool "m8i.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_METAL_48XL
+ bool "m8i.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 768.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_METAL_96XL
+ bool "m8i.metal-96xl"
+ help
+ vCPUs: 384
+ Memory: 1536.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_M8I_96XLARGE
+ bool "m8i.96xlarge"
+ help
+ vCPUs: 384
+ Memory: 1536.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_M8I_SIZE
+ string
+ default "m8i.large" if TERRAFORM_AWS_INSTANCE_M8I_LARGE
+ default "m8i.xlarge" if TERRAFORM_AWS_INSTANCE_M8I_XLARGE
+ default "m8i.2xlarge" if TERRAFORM_AWS_INSTANCE_M8I_2XLARGE
+ default "m8i.4xlarge" if TERRAFORM_AWS_INSTANCE_M8I_4XLARGE
+ default "m8i.8xlarge" if TERRAFORM_AWS_INSTANCE_M8I_8XLARGE
+ default "m8i.12xlarge" if TERRAFORM_AWS_INSTANCE_M8I_12XLARGE
+ default "m8i.16xlarge" if TERRAFORM_AWS_INSTANCE_M8I_16XLARGE
+ default "m8i.24xlarge" if TERRAFORM_AWS_INSTANCE_M8I_24XLARGE
+ default "m8i.32xlarge" if TERRAFORM_AWS_INSTANCE_M8I_32XLARGE
+ default "m8i.48xlarge" if TERRAFORM_AWS_INSTANCE_M8I_48XLARGE
+ default "m8i.metal-48xl" if TERRAFORM_AWS_INSTANCE_M8I_METAL_48XL
+ default "m8i.metal-96xl" if TERRAFORM_AWS_INSTANCE_M8I_METAL_96XL
+ default "m8i.96xlarge" if TERRAFORM_AWS_INSTANCE_M8I_96XLARGE
+ default "m8i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.mac1.static b/terraform/aws/kconfigs/instance-types/Kconfig.mac1.static
new file mode 100644
index 00000000..1d30fd58
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.mac1.static
@@ -0,0 +1,23 @@
+# AWS MAC1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for MAC1 family"
+ default TERRAFORM_AWS_INSTANCE_MAC1_METAL
+ help
+ Select the specific instance size within the MAC1 family.
+
+config TERRAFORM_AWS_INSTANCE_MAC1_METAL
+ bool "mac1.metal"
+ help
+ vCPUs: 12
+ Memory: 32.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_MAC1_SIZE
+ string
+ default "mac1.metal" if TERRAFORM_AWS_INSTANCE_MAC1_METAL
+ default "mac1.metal"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m1ultra.static b/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m1ultra.static
new file mode 100644
index 00000000..f913b411
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m1ultra.static
@@ -0,0 +1,23 @@
+# AWS MAC2-M1ULTRA instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for MAC2-M1ULTRA family"
+ default TERRAFORM_AWS_INSTANCE_MAC2_M1ULTRA_METAL
+ help
+ Select the specific instance size within the MAC2-M1ULTRA family.
+
+config TERRAFORM_AWS_INSTANCE_MAC2_M1ULTRA_METAL
+ bool "mac2-m1ultra.metal"
+ help
+ vCPUs: 20
+ Memory: 128.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_MAC2_M1ULTRA_SIZE
+ string
+ default "mac2-m1ultra.metal" if TERRAFORM_AWS_INSTANCE_MAC2_M1ULTRA_METAL
+ default "mac2-m1ultra.metal"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2.static b/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2.static
new file mode 100644
index 00000000..a59bae31
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2.static
@@ -0,0 +1,23 @@
+# AWS MAC2-M2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for MAC2-M2 family"
+ default TERRAFORM_AWS_INSTANCE_MAC2_M2_METAL
+ help
+ Select the specific instance size within the MAC2-M2 family.
+
+config TERRAFORM_AWS_INSTANCE_MAC2_M2_METAL
+ bool "mac2-m2.metal"
+ help
+ vCPUs: 8
+ Memory: 24.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_MAC2_M2_SIZE
+ string
+ default "mac2-m2.metal" if TERRAFORM_AWS_INSTANCE_MAC2_M2_METAL
+ default "mac2-m2.metal"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2pro.static b/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2pro.static
new file mode 100644
index 00000000..75509e9a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.mac2-m2pro.static
@@ -0,0 +1,23 @@
+# AWS MAC2-M2PRO instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for MAC2-M2PRO family"
+ default TERRAFORM_AWS_INSTANCE_MAC2_M2PRO_METAL
+ help
+ Select the specific instance size within the MAC2-M2PRO family.
+
+config TERRAFORM_AWS_INSTANCE_MAC2_M2PRO_METAL
+ bool "mac2-m2pro.metal"
+ help
+ vCPUs: 12
+ Memory: 32.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_MAC2_M2PRO_SIZE
+ string
+ default "mac2-m2pro.metal" if TERRAFORM_AWS_INSTANCE_MAC2_M2PRO_METAL
+ default "mac2-m2pro.metal"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.mac2.static b/terraform/aws/kconfigs/instance-types/Kconfig.mac2.static
new file mode 100644
index 00000000..54fa31ef
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.mac2.static
@@ -0,0 +1,23 @@
+# AWS MAC2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for MAC2 family"
+ default TERRAFORM_AWS_INSTANCE_MAC2_METAL
+ help
+ Select the specific instance size within the MAC2 family.
+
+config TERRAFORM_AWS_INSTANCE_MAC2_METAL
+ bool "mac2.metal"
+ help
+ vCPUs: 8
+ Memory: 16.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_MAC2_SIZE
+ string
+ default "mac2.metal" if TERRAFORM_AWS_INSTANCE_MAC2_METAL
+ default "mac2.metal"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.p3.static b/terraform/aws/kconfigs/instance-types/Kconfig.p3.static
new file mode 100644
index 00000000..eccbc9dd
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.p3.static
@@ -0,0 +1,41 @@
+# AWS P3 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for P3 family"
+ default TERRAFORM_AWS_INSTANCE_P3_2XLARGE
+ help
+ Select the specific instance size within the P3 family.
+
+config TERRAFORM_AWS_INSTANCE_P3_2XLARGE
+ bool "p3.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 61.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_P3_8XLARGE
+ bool "p3.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 244.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_P3_16XLARGE
+ bool "p3.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 488.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_P3_SIZE
+ string
+ default "p3.2xlarge" if TERRAFORM_AWS_INSTANCE_P3_2XLARGE
+ default "p3.8xlarge" if TERRAFORM_AWS_INSTANCE_P3_8XLARGE
+ default "p3.16xlarge" if TERRAFORM_AWS_INSTANCE_P3_16XLARGE
+ default "p3.2xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.p3dn.static b/terraform/aws/kconfigs/instance-types/Kconfig.p3dn.static
new file mode 100644
index 00000000..382b3ff0
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.p3dn.static
@@ -0,0 +1,24 @@
+# AWS P3DN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for P3DN family"
+ default TERRAFORM_AWS_INSTANCE_P3DN_24XLARGE
+ help
+ Select the specific instance size within the P3DN family.
+
+config TERRAFORM_AWS_INSTANCE_P3DN_24XLARGE
+ bool "p3dn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+endchoice
+
+config TERRAFORM_AWS_P3DN_SIZE
+ string
+ default "p3dn.24xlarge" if TERRAFORM_AWS_INSTANCE_P3DN_24XLARGE
+ default "p3dn.24xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.p4d.static b/terraform/aws/kconfigs/instance-types/Kconfig.p4d.static
new file mode 100644
index 00000000..470b300a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.p4d.static
@@ -0,0 +1,24 @@
+# AWS P4D instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for P4D family"
+ default TERRAFORM_AWS_INSTANCE_P4D_24XLARGE
+ help
+ Select the specific instance size within the P4D family.
+
+config TERRAFORM_AWS_INSTANCE_P4D_24XLARGE
+ bool "p4d.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 1152.0 GB
+ Network: 4x 100 Gigabit
+ Price: pricing varies
+ Instance storage: 8000 GB
+
+endchoice
+
+config TERRAFORM_AWS_P4D_SIZE
+ string
+ default "p4d.24xlarge" if TERRAFORM_AWS_INSTANCE_P4D_24XLARGE
+ default "p4d.24xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.p4de.static b/terraform/aws/kconfigs/instance-types/Kconfig.p4de.static
new file mode 100644
index 00000000..cc6fd22e
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.p4de.static
@@ -0,0 +1,24 @@
+# AWS P4DE instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for P4DE family"
+ default TERRAFORM_AWS_INSTANCE_P4DE_24XLARGE
+ help
+ Select the specific instance size within the P4DE family.
+
+config TERRAFORM_AWS_INSTANCE_P4DE_24XLARGE
+ bool "p4de.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 1152.0 GB
+ Network: 4x 100 Gigabit
+ Price: pricing varies
+ Instance storage: 8000 GB
+
+endchoice
+
+config TERRAFORM_AWS_P4DE_SIZE
+ string
+ default "p4de.24xlarge" if TERRAFORM_AWS_INSTANCE_P4DE_24XLARGE
+ default "p4de.24xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.p5.static b/terraform/aws/kconfigs/instance-types/Kconfig.p5.static
new file mode 100644
index 00000000..66295cb9
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.p5.static
@@ -0,0 +1,34 @@
+# AWS P5 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for P5 family"
+ default TERRAFORM_AWS_INSTANCE_P5_4XLARGE
+ help
+ Select the specific instance size within the P5 family.
+
+config TERRAFORM_AWS_INSTANCE_P5_4XLARGE
+ bool "p5.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 256.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_P5_48XLARGE
+ bool "p5.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 2048.0 GB
+ Network: 3200 Gigabit
+ Price: pricing varies
+ Instance storage: 30400 GB
+
+endchoice
+
+config TERRAFORM_AWS_P5_SIZE
+ string
+ default "p5.4xlarge" if TERRAFORM_AWS_INSTANCE_P5_4XLARGE
+ default "p5.48xlarge" if TERRAFORM_AWS_INSTANCE_P5_48XLARGE
+ default "p5.4xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.p5en.static b/terraform/aws/kconfigs/instance-types/Kconfig.p5en.static
new file mode 100644
index 00000000..30797617
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.p5en.static
@@ -0,0 +1,24 @@
+# AWS P5EN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for P5EN family"
+ default TERRAFORM_AWS_INSTANCE_P5EN_48XLARGE
+ help
+ Select the specific instance size within the P5EN family.
+
+config TERRAFORM_AWS_INSTANCE_P5EN_48XLARGE
+ bool "p5en.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 2048.0 GB
+ Network: 3200 Gigabit
+ Price: pricing varies
+ Instance storage: 30400 GB
+
+endchoice
+
+config TERRAFORM_AWS_P5EN_SIZE
+ string
+ default "p5en.48xlarge" if TERRAFORM_AWS_INSTANCE_P5EN_48XLARGE
+ default "p5en.48xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.p6-b200.static b/terraform/aws/kconfigs/instance-types/Kconfig.p6-b200.static
new file mode 100644
index 00000000..7fb90278
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.p6-b200.static
@@ -0,0 +1,24 @@
+# AWS P6-B200 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for P6-B200 family"
+ default TERRAFORM_AWS_INSTANCE_P6_B200_48XLARGE
+ help
+ Select the specific instance size within the P6-B200 family.
+
+config TERRAFORM_AWS_INSTANCE_P6_B200_48XLARGE
+ bool "p6-b200.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 2048.0 GB
+ Network: 3200 Gigabit
+ Price: pricing varies
+ Instance storage: 30400 GB
+
+endchoice
+
+config TERRAFORM_AWS_P6_B200_SIZE
+ string
+ default "p6-b200.48xlarge" if TERRAFORM_AWS_INSTANCE_P6_B200_48XLARGE
+ default "p6-b200.48xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r3.static b/terraform/aws/kconfigs/instance-types/Kconfig.r3.static
new file mode 100644
index 00000000..fd3b44c4
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r3.static
@@ -0,0 +1,64 @@
+# AWS R3 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R3 family"
+ default TERRAFORM_AWS_INSTANCE_R3_LARGE
+ help
+ Select the specific instance size within the R3 family.
+
+config TERRAFORM_AWS_INSTANCE_R3_LARGE
+ bool "r3.large"
+ help
+ vCPUs: 2
+ Memory: 15.0 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 32 GB
+
+config TERRAFORM_AWS_INSTANCE_R3_XLARGE
+ bool "r3.xlarge"
+ help
+ vCPUs: 4
+ Memory: 30.5 GB
+ Network: Moderate
+ Price: pricing varies
+ Instance storage: 80 GB
+
+config TERRAFORM_AWS_INSTANCE_R3_2XLARGE
+ bool "r3.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 61.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 160 GB
+
+config TERRAFORM_AWS_INSTANCE_R3_4XLARGE
+ bool "r3.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 122.0 GB
+ Network: High
+ Price: pricing varies
+ Instance storage: 320 GB
+
+config TERRAFORM_AWS_INSTANCE_R3_8XLARGE
+ bool "r3.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 244.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 640 GB
+
+endchoice
+
+config TERRAFORM_AWS_R3_SIZE
+ string
+ default "r3.large" if TERRAFORM_AWS_INSTANCE_R3_LARGE
+ default "r3.xlarge" if TERRAFORM_AWS_INSTANCE_R3_XLARGE
+ default "r3.2xlarge" if TERRAFORM_AWS_INSTANCE_R3_2XLARGE
+ default "r3.4xlarge" if TERRAFORM_AWS_INSTANCE_R3_4XLARGE
+ default "r3.8xlarge" if TERRAFORM_AWS_INSTANCE_R3_8XLARGE
+ default "r3.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r4.static b/terraform/aws/kconfigs/instance-types/Kconfig.r4.static
new file mode 100644
index 00000000..f13977f9
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r4.static
@@ -0,0 +1,68 @@
+# AWS R4 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R4 family"
+ default TERRAFORM_AWS_INSTANCE_R4_LARGE
+ help
+ Select the specific instance size within the R4 family.
+
+config TERRAFORM_AWS_INSTANCE_R4_LARGE
+ bool "r4.large"
+ help
+ vCPUs: 2
+ Memory: 15.2 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R4_XLARGE
+ bool "r4.xlarge"
+ help
+ vCPUs: 4
+ Memory: 30.5 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R4_2XLARGE
+ bool "r4.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 61.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R4_4XLARGE
+ bool "r4.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 122.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R4_8XLARGE
+ bool "r4.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 244.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R4_16XLARGE
+ bool "r4.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 488.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R4_SIZE
+ string
+ default "r4.large" if TERRAFORM_AWS_INSTANCE_R4_LARGE
+ default "r4.xlarge" if TERRAFORM_AWS_INSTANCE_R4_XLARGE
+ default "r4.2xlarge" if TERRAFORM_AWS_INSTANCE_R4_2XLARGE
+ default "r4.4xlarge" if TERRAFORM_AWS_INSTANCE_R4_4XLARGE
+ default "r4.8xlarge" if TERRAFORM_AWS_INSTANCE_R4_8XLARGE
+ default "r4.16xlarge" if TERRAFORM_AWS_INSTANCE_R4_16XLARGE
+ default "r4.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r5.static b/terraform/aws/kconfigs/instance-types/Kconfig.r5.static
new file mode 100644
index 00000000..a874366e
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r5.static
@@ -0,0 +1,95 @@
+# AWS R5 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R5 family"
+ default TERRAFORM_AWS_INSTANCE_R5_LARGE
+ help
+ Select the specific instance size within the R5 family.
+
+config TERRAFORM_AWS_INSTANCE_R5_LARGE
+ bool "r5.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_XLARGE
+ bool "r5.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_2XLARGE
+ bool "r5.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_4XLARGE
+ bool "r5.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_8XLARGE
+ bool "r5.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_12XLARGE
+ bool "r5.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_16XLARGE
+ bool "r5.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_24XLARGE
+ bool "r5.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5_METAL
+ bool "r5.metal"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R5_SIZE
+ string
+ default "r5.large" if TERRAFORM_AWS_INSTANCE_R5_LARGE
+ default "r5.xlarge" if TERRAFORM_AWS_INSTANCE_R5_XLARGE
+ default "r5.2xlarge" if TERRAFORM_AWS_INSTANCE_R5_2XLARGE
+ default "r5.4xlarge" if TERRAFORM_AWS_INSTANCE_R5_4XLARGE
+ default "r5.8xlarge" if TERRAFORM_AWS_INSTANCE_R5_8XLARGE
+ default "r5.12xlarge" if TERRAFORM_AWS_INSTANCE_R5_12XLARGE
+ default "r5.16xlarge" if TERRAFORM_AWS_INSTANCE_R5_16XLARGE
+ default "r5.24xlarge" if TERRAFORM_AWS_INSTANCE_R5_24XLARGE
+ default "r5.metal" if TERRAFORM_AWS_INSTANCE_R5_METAL
+ default "r5.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r5a.static b/terraform/aws/kconfigs/instance-types/Kconfig.r5a.static
new file mode 100644
index 00000000..c019c004
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r5a.static
@@ -0,0 +1,86 @@
+# AWS R5A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R5A family"
+ default TERRAFORM_AWS_INSTANCE_R5A_LARGE
+ help
+ Select the specific instance size within the R5A family.
+
+config TERRAFORM_AWS_INSTANCE_R5A_LARGE
+ bool "r5a.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5A_XLARGE
+ bool "r5a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5A_2XLARGE
+ bool "r5a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5A_4XLARGE
+ bool "r5a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5A_8XLARGE
+ bool "r5a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5A_12XLARGE
+ bool "r5a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5A_16XLARGE
+ bool "r5a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5A_24XLARGE
+ bool "r5a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R5A_SIZE
+ string
+ default "r5a.large" if TERRAFORM_AWS_INSTANCE_R5A_LARGE
+ default "r5a.xlarge" if TERRAFORM_AWS_INSTANCE_R5A_XLARGE
+ default "r5a.2xlarge" if TERRAFORM_AWS_INSTANCE_R5A_2XLARGE
+ default "r5a.4xlarge" if TERRAFORM_AWS_INSTANCE_R5A_4XLARGE
+ default "r5a.8xlarge" if TERRAFORM_AWS_INSTANCE_R5A_8XLARGE
+ default "r5a.12xlarge" if TERRAFORM_AWS_INSTANCE_R5A_12XLARGE
+ default "r5a.16xlarge" if TERRAFORM_AWS_INSTANCE_R5A_16XLARGE
+ default "r5a.24xlarge" if TERRAFORM_AWS_INSTANCE_R5A_24XLARGE
+ default "r5a.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r5ad.static b/terraform/aws/kconfigs/instance-types/Kconfig.r5ad.static
new file mode 100644
index 00000000..a1ba3d26
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r5ad.static
@@ -0,0 +1,94 @@
+# AWS R5AD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R5AD family"
+ default TERRAFORM_AWS_INSTANCE_R5AD_LARGE
+ help
+ Select the specific instance size within the R5AD family.
+
+config TERRAFORM_AWS_INSTANCE_R5AD_LARGE
+ bool "r5ad.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_R5AD_XLARGE
+ bool "r5ad.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_R5AD_2XLARGE
+ bool "r5ad.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_R5AD_4XLARGE
+ bool "r5ad.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_R5AD_8XLARGE
+ bool "r5ad.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_R5AD_12XLARGE
+ bool "r5ad.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_R5AD_16XLARGE
+ bool "r5ad.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+config TERRAFORM_AWS_INSTANCE_R5AD_24XLARGE
+ bool "r5ad.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+endchoice
+
+config TERRAFORM_AWS_R5AD_SIZE
+ string
+ default "r5ad.large" if TERRAFORM_AWS_INSTANCE_R5AD_LARGE
+ default "r5ad.xlarge" if TERRAFORM_AWS_INSTANCE_R5AD_XLARGE
+ default "r5ad.2xlarge" if TERRAFORM_AWS_INSTANCE_R5AD_2XLARGE
+ default "r5ad.4xlarge" if TERRAFORM_AWS_INSTANCE_R5AD_4XLARGE
+ default "r5ad.8xlarge" if TERRAFORM_AWS_INSTANCE_R5AD_8XLARGE
+ default "r5ad.12xlarge" if TERRAFORM_AWS_INSTANCE_R5AD_12XLARGE
+ default "r5ad.16xlarge" if TERRAFORM_AWS_INSTANCE_R5AD_16XLARGE
+ default "r5ad.24xlarge" if TERRAFORM_AWS_INSTANCE_R5AD_24XLARGE
+ default "r5ad.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r5b.static b/terraform/aws/kconfigs/instance-types/Kconfig.r5b.static
new file mode 100644
index 00000000..dc6f701c
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r5b.static
@@ -0,0 +1,95 @@
+# AWS R5B instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R5B family"
+ default TERRAFORM_AWS_INSTANCE_R5B_LARGE
+ help
+ Select the specific instance size within the R5B family.
+
+config TERRAFORM_AWS_INSTANCE_R5B_LARGE
+ bool "r5b.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_XLARGE
+ bool "r5b.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_2XLARGE
+ bool "r5b.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_4XLARGE
+ bool "r5b.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_8XLARGE
+ bool "r5b.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_12XLARGE
+ bool "r5b.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_16XLARGE
+ bool "r5b.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_METAL
+ bool "r5b.metal"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5B_24XLARGE
+ bool "r5b.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R5B_SIZE
+ string
+ default "r5b.large" if TERRAFORM_AWS_INSTANCE_R5B_LARGE
+ default "r5b.xlarge" if TERRAFORM_AWS_INSTANCE_R5B_XLARGE
+ default "r5b.2xlarge" if TERRAFORM_AWS_INSTANCE_R5B_2XLARGE
+ default "r5b.4xlarge" if TERRAFORM_AWS_INSTANCE_R5B_4XLARGE
+ default "r5b.8xlarge" if TERRAFORM_AWS_INSTANCE_R5B_8XLARGE
+ default "r5b.12xlarge" if TERRAFORM_AWS_INSTANCE_R5B_12XLARGE
+ default "r5b.16xlarge" if TERRAFORM_AWS_INSTANCE_R5B_16XLARGE
+ default "r5b.metal" if TERRAFORM_AWS_INSTANCE_R5B_METAL
+ default "r5b.24xlarge" if TERRAFORM_AWS_INSTANCE_R5B_24XLARGE
+ default "r5b.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r5d.static b/terraform/aws/kconfigs/instance-types/Kconfig.r5d.static
new file mode 100644
index 00000000..3e6222dc
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r5d.static
@@ -0,0 +1,104 @@
+# AWS R5D instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R5D family"
+ default TERRAFORM_AWS_INSTANCE_R5D_LARGE
+ help
+ Select the specific instance size within the R5D family.
+
+config TERRAFORM_AWS_INSTANCE_R5D_LARGE
+ bool "r5d.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_XLARGE
+ bool "r5d.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_2XLARGE
+ bool "r5d.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_4XLARGE
+ bool "r5d.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_8XLARGE
+ bool "r5d.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_12XLARGE
+ bool "r5d.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_16XLARGE
+ bool "r5d.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_24XLARGE
+ bool "r5d.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+config TERRAFORM_AWS_INSTANCE_R5D_METAL
+ bool "r5d.metal"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+endchoice
+
+config TERRAFORM_AWS_R5D_SIZE
+ string
+ default "r5d.large" if TERRAFORM_AWS_INSTANCE_R5D_LARGE
+ default "r5d.xlarge" if TERRAFORM_AWS_INSTANCE_R5D_XLARGE
+ default "r5d.2xlarge" if TERRAFORM_AWS_INSTANCE_R5D_2XLARGE
+ default "r5d.4xlarge" if TERRAFORM_AWS_INSTANCE_R5D_4XLARGE
+ default "r5d.8xlarge" if TERRAFORM_AWS_INSTANCE_R5D_8XLARGE
+ default "r5d.12xlarge" if TERRAFORM_AWS_INSTANCE_R5D_12XLARGE
+ default "r5d.16xlarge" if TERRAFORM_AWS_INSTANCE_R5D_16XLARGE
+ default "r5d.24xlarge" if TERRAFORM_AWS_INSTANCE_R5D_24XLARGE
+ default "r5d.metal" if TERRAFORM_AWS_INSTANCE_R5D_METAL
+ default "r5d.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r5dn.static b/terraform/aws/kconfigs/instance-types/Kconfig.r5dn.static
new file mode 100644
index 00000000..81850d4f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r5dn.static
@@ -0,0 +1,104 @@
+# AWS R5DN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R5DN family"
+ default TERRAFORM_AWS_INSTANCE_R5DN_LARGE
+ help
+ Select the specific instance size within the R5DN family.
+
+config TERRAFORM_AWS_INSTANCE_R5DN_LARGE
+ bool "r5dn.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_XLARGE
+ bool "r5dn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_2XLARGE
+ bool "r5dn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_4XLARGE
+ bool "r5dn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 600 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_8XLARGE
+ bool "r5dn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1200 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_12XLARGE
+ bool "r5dn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_16XLARGE
+ bool "r5dn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 2400 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_METAL
+ bool "r5dn.metal"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+config TERRAFORM_AWS_INSTANCE_R5DN_24XLARGE
+ bool "r5dn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3600 GB
+
+endchoice
+
+config TERRAFORM_AWS_R5DN_SIZE
+ string
+ default "r5dn.large" if TERRAFORM_AWS_INSTANCE_R5DN_LARGE
+ default "r5dn.xlarge" if TERRAFORM_AWS_INSTANCE_R5DN_XLARGE
+ default "r5dn.2xlarge" if TERRAFORM_AWS_INSTANCE_R5DN_2XLARGE
+ default "r5dn.4xlarge" if TERRAFORM_AWS_INSTANCE_R5DN_4XLARGE
+ default "r5dn.8xlarge" if TERRAFORM_AWS_INSTANCE_R5DN_8XLARGE
+ default "r5dn.12xlarge" if TERRAFORM_AWS_INSTANCE_R5DN_12XLARGE
+ default "r5dn.16xlarge" if TERRAFORM_AWS_INSTANCE_R5DN_16XLARGE
+ default "r5dn.metal" if TERRAFORM_AWS_INSTANCE_R5DN_METAL
+ default "r5dn.24xlarge" if TERRAFORM_AWS_INSTANCE_R5DN_24XLARGE
+ default "r5dn.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r5n.static b/terraform/aws/kconfigs/instance-types/Kconfig.r5n.static
new file mode 100644
index 00000000..3992c9ca
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r5n.static
@@ -0,0 +1,95 @@
+# AWS R5N instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R5N family"
+ default TERRAFORM_AWS_INSTANCE_R5N_LARGE
+ help
+ Select the specific instance size within the R5N family.
+
+config TERRAFORM_AWS_INSTANCE_R5N_LARGE
+ bool "r5n.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_XLARGE
+ bool "r5n.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_2XLARGE
+ bool "r5n.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_4XLARGE
+ bool "r5n.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_8XLARGE
+ bool "r5n.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_12XLARGE
+ bool "r5n.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_16XLARGE
+ bool "r5n.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_24XLARGE
+ bool "r5n.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R5N_METAL
+ bool "r5n.metal"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R5N_SIZE
+ string
+ default "r5n.large" if TERRAFORM_AWS_INSTANCE_R5N_LARGE
+ default "r5n.xlarge" if TERRAFORM_AWS_INSTANCE_R5N_XLARGE
+ default "r5n.2xlarge" if TERRAFORM_AWS_INSTANCE_R5N_2XLARGE
+ default "r5n.4xlarge" if TERRAFORM_AWS_INSTANCE_R5N_4XLARGE
+ default "r5n.8xlarge" if TERRAFORM_AWS_INSTANCE_R5N_8XLARGE
+ default "r5n.12xlarge" if TERRAFORM_AWS_INSTANCE_R5N_12XLARGE
+ default "r5n.16xlarge" if TERRAFORM_AWS_INSTANCE_R5N_16XLARGE
+ default "r5n.24xlarge" if TERRAFORM_AWS_INSTANCE_R5N_24XLARGE
+ default "r5n.metal" if TERRAFORM_AWS_INSTANCE_R5N_METAL
+ default "r5n.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r6a.static b/terraform/aws/kconfigs/instance-types/Kconfig.r6a.static
new file mode 100644
index 00000000..f89184e5
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r6a.static
@@ -0,0 +1,113 @@
+# AWS R6A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R6A family"
+ default TERRAFORM_AWS_INSTANCE_R6A_LARGE
+ help
+ Select the specific instance size within the R6A family.
+
+config TERRAFORM_AWS_INSTANCE_R6A_LARGE
+ bool "r6a.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_XLARGE
+ bool "r6a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_2XLARGE
+ bool "r6a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_4XLARGE
+ bool "r6a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_8XLARGE
+ bool "r6a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_12XLARGE
+ bool "r6a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_16XLARGE
+ bool "r6a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_24XLARGE
+ bool "r6a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_32XLARGE
+ bool "r6a.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_METAL
+ bool "r6a.metal"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6A_48XLARGE
+ bool "r6a.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R6A_SIZE
+ string
+ default "r6a.large" if TERRAFORM_AWS_INSTANCE_R6A_LARGE
+ default "r6a.xlarge" if TERRAFORM_AWS_INSTANCE_R6A_XLARGE
+ default "r6a.2xlarge" if TERRAFORM_AWS_INSTANCE_R6A_2XLARGE
+ default "r6a.4xlarge" if TERRAFORM_AWS_INSTANCE_R6A_4XLARGE
+ default "r6a.8xlarge" if TERRAFORM_AWS_INSTANCE_R6A_8XLARGE
+ default "r6a.12xlarge" if TERRAFORM_AWS_INSTANCE_R6A_12XLARGE
+ default "r6a.16xlarge" if TERRAFORM_AWS_INSTANCE_R6A_16XLARGE
+ default "r6a.24xlarge" if TERRAFORM_AWS_INSTANCE_R6A_24XLARGE
+ default "r6a.32xlarge" if TERRAFORM_AWS_INSTANCE_R6A_32XLARGE
+ default "r6a.metal" if TERRAFORM_AWS_INSTANCE_R6A_METAL
+ default "r6a.48xlarge" if TERRAFORM_AWS_INSTANCE_R6A_48XLARGE
+ default "r6a.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r6g.static b/terraform/aws/kconfigs/instance-types/Kconfig.r6g.static
new file mode 100644
index 00000000..4dfd454f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r6g.static
@@ -0,0 +1,95 @@
+# AWS R6G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R6G family"
+ default TERRAFORM_AWS_INSTANCE_R6G_MEDIUM
+ help
+ Select the specific instance size within the R6G family.
+
+config TERRAFORM_AWS_INSTANCE_R6G_MEDIUM
+ bool "r6g.medium"
+ help
+ vCPUs: 1
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_LARGE
+ bool "r6g.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_XLARGE
+ bool "r6g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_2XLARGE
+ bool "r6g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_4XLARGE
+ bool "r6g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_8XLARGE
+ bool "r6g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_12XLARGE
+ bool "r6g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_16XLARGE
+ bool "r6g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6G_METAL
+ bool "r6g.metal"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R6G_SIZE
+ string
+ default "r6g.medium" if TERRAFORM_AWS_INSTANCE_R6G_MEDIUM
+ default "r6g.large" if TERRAFORM_AWS_INSTANCE_R6G_LARGE
+ default "r6g.xlarge" if TERRAFORM_AWS_INSTANCE_R6G_XLARGE
+ default "r6g.2xlarge" if TERRAFORM_AWS_INSTANCE_R6G_2XLARGE
+ default "r6g.4xlarge" if TERRAFORM_AWS_INSTANCE_R6G_4XLARGE
+ default "r6g.8xlarge" if TERRAFORM_AWS_INSTANCE_R6G_8XLARGE
+ default "r6g.12xlarge" if TERRAFORM_AWS_INSTANCE_R6G_12XLARGE
+ default "r6g.16xlarge" if TERRAFORM_AWS_INSTANCE_R6G_16XLARGE
+ default "r6g.metal" if TERRAFORM_AWS_INSTANCE_R6G_METAL
+ default "r6g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r6gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.r6gd.static
new file mode 100644
index 00000000..9ba8ccc4
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r6gd.static
@@ -0,0 +1,104 @@
+# AWS R6GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R6GD family"
+ default TERRAFORM_AWS_INSTANCE_R6GD_MEDIUM
+ help
+ Select the specific instance size within the R6GD family.
+
+config TERRAFORM_AWS_INSTANCE_R6GD_MEDIUM
+ bool "r6gd.medium"
+ help
+ vCPUs: 1
+ Memory: 8.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_LARGE
+ bool "r6gd.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_XLARGE
+ bool "r6gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_2XLARGE
+ bool "r6gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_4XLARGE
+ bool "r6gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_8XLARGE
+ bool "r6gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_12XLARGE
+ bool "r6gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_METAL
+ bool "r6gd.metal"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_R6GD_16XLARGE
+ bool "r6gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_R6GD_SIZE
+ string
+ default "r6gd.medium" if TERRAFORM_AWS_INSTANCE_R6GD_MEDIUM
+ default "r6gd.large" if TERRAFORM_AWS_INSTANCE_R6GD_LARGE
+ default "r6gd.xlarge" if TERRAFORM_AWS_INSTANCE_R6GD_XLARGE
+ default "r6gd.2xlarge" if TERRAFORM_AWS_INSTANCE_R6GD_2XLARGE
+ default "r6gd.4xlarge" if TERRAFORM_AWS_INSTANCE_R6GD_4XLARGE
+ default "r6gd.8xlarge" if TERRAFORM_AWS_INSTANCE_R6GD_8XLARGE
+ default "r6gd.12xlarge" if TERRAFORM_AWS_INSTANCE_R6GD_12XLARGE
+ default "r6gd.metal" if TERRAFORM_AWS_INSTANCE_R6GD_METAL
+ default "r6gd.16xlarge" if TERRAFORM_AWS_INSTANCE_R6GD_16XLARGE
+ default "r6gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r6i.static b/terraform/aws/kconfigs/instance-types/Kconfig.r6i.static
new file mode 100644
index 00000000..7191f8e3
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r6i.static
@@ -0,0 +1,104 @@
+# AWS R6I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R6I family"
+ default TERRAFORM_AWS_INSTANCE_R6I_LARGE
+ help
+ Select the specific instance size within the R6I family.
+
+config TERRAFORM_AWS_INSTANCE_R6I_LARGE
+ bool "r6i.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_XLARGE
+ bool "r6i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_2XLARGE
+ bool "r6i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_4XLARGE
+ bool "r6i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_8XLARGE
+ bool "r6i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_12XLARGE
+ bool "r6i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_16XLARGE
+ bool "r6i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_24XLARGE
+ bool "r6i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_METAL
+ bool "r6i.metal"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6I_32XLARGE
+ bool "r6i.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R6I_SIZE
+ string
+ default "r6i.large" if TERRAFORM_AWS_INSTANCE_R6I_LARGE
+ default "r6i.xlarge" if TERRAFORM_AWS_INSTANCE_R6I_XLARGE
+ default "r6i.2xlarge" if TERRAFORM_AWS_INSTANCE_R6I_2XLARGE
+ default "r6i.4xlarge" if TERRAFORM_AWS_INSTANCE_R6I_4XLARGE
+ default "r6i.8xlarge" if TERRAFORM_AWS_INSTANCE_R6I_8XLARGE
+ default "r6i.12xlarge" if TERRAFORM_AWS_INSTANCE_R6I_12XLARGE
+ default "r6i.16xlarge" if TERRAFORM_AWS_INSTANCE_R6I_16XLARGE
+ default "r6i.24xlarge" if TERRAFORM_AWS_INSTANCE_R6I_24XLARGE
+ default "r6i.metal" if TERRAFORM_AWS_INSTANCE_R6I_METAL
+ default "r6i.32xlarge" if TERRAFORM_AWS_INSTANCE_R6I_32XLARGE
+ default "r6i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r6id.static b/terraform/aws/kconfigs/instance-types/Kconfig.r6id.static
new file mode 100644
index 00000000..dc141e43
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r6id.static
@@ -0,0 +1,114 @@
+# AWS R6ID instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R6ID family"
+ default TERRAFORM_AWS_INSTANCE_R6ID_LARGE
+ help
+ Select the specific instance size within the R6ID family.
+
+config TERRAFORM_AWS_INSTANCE_R6ID_LARGE
+ bool "r6id.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_XLARGE
+ bool "r6id.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_2XLARGE
+ bool "r6id.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_4XLARGE
+ bool "r6id.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_8XLARGE
+ bool "r6id.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_12XLARGE
+ bool "r6id.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_16XLARGE
+ bool "r6id.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_24XLARGE
+ bool "r6id.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_32XLARGE
+ bool "r6id.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+config TERRAFORM_AWS_INSTANCE_R6ID_METAL
+ bool "r6id.metal"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_R6ID_SIZE
+ string
+ default "r6id.large" if TERRAFORM_AWS_INSTANCE_R6ID_LARGE
+ default "r6id.xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_XLARGE
+ default "r6id.2xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_2XLARGE
+ default "r6id.4xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_4XLARGE
+ default "r6id.8xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_8XLARGE
+ default "r6id.12xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_12XLARGE
+ default "r6id.16xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_16XLARGE
+ default "r6id.24xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_24XLARGE
+ default "r6id.32xlarge" if TERRAFORM_AWS_INSTANCE_R6ID_32XLARGE
+ default "r6id.metal" if TERRAFORM_AWS_INSTANCE_R6ID_METAL
+ default "r6id.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r6idn.static b/terraform/aws/kconfigs/instance-types/Kconfig.r6idn.static
new file mode 100644
index 00000000..2700c7d0
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r6idn.static
@@ -0,0 +1,114 @@
+# AWS R6IDN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R6IDN family"
+ default TERRAFORM_AWS_INSTANCE_R6IDN_LARGE
+ help
+ Select the specific instance size within the R6IDN family.
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_LARGE
+ bool "r6idn.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_XLARGE
+ bool "r6idn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_2XLARGE
+ bool "r6idn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 40 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_4XLARGE
+ bool "r6idn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_8XLARGE
+ bool "r6idn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_12XLARGE
+ bool "r6idn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_16XLARGE
+ bool "r6idn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_24XLARGE
+ bool "r6idn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_METAL
+ bool "r6idn.metal"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+config TERRAFORM_AWS_INSTANCE_R6IDN_32XLARGE
+ bool "r6idn.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_R6IDN_SIZE
+ string
+ default "r6idn.large" if TERRAFORM_AWS_INSTANCE_R6IDN_LARGE
+ default "r6idn.xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_XLARGE
+ default "r6idn.2xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_2XLARGE
+ default "r6idn.4xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_4XLARGE
+ default "r6idn.8xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_8XLARGE
+ default "r6idn.12xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_12XLARGE
+ default "r6idn.16xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_16XLARGE
+ default "r6idn.24xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_24XLARGE
+ default "r6idn.metal" if TERRAFORM_AWS_INSTANCE_R6IDN_METAL
+ default "r6idn.32xlarge" if TERRAFORM_AWS_INSTANCE_R6IDN_32XLARGE
+ default "r6idn.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r6in.static b/terraform/aws/kconfigs/instance-types/Kconfig.r6in.static
new file mode 100644
index 00000000..f5df78b0
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r6in.static
@@ -0,0 +1,104 @@
+# AWS R6IN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R6IN family"
+ default TERRAFORM_AWS_INSTANCE_R6IN_LARGE
+ help
+ Select the specific instance size within the R6IN family.
+
+config TERRAFORM_AWS_INSTANCE_R6IN_LARGE
+ bool "r6in.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_XLARGE
+ bool "r6in.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_2XLARGE
+ bool "r6in.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_4XLARGE
+ bool "r6in.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_8XLARGE
+ bool "r6in.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_12XLARGE
+ bool "r6in.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_16XLARGE
+ bool "r6in.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_24XLARGE
+ bool "r6in.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 150 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_METAL
+ bool "r6in.metal"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R6IN_32XLARGE
+ bool "r6in.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R6IN_SIZE
+ string
+ default "r6in.large" if TERRAFORM_AWS_INSTANCE_R6IN_LARGE
+ default "r6in.xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_XLARGE
+ default "r6in.2xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_2XLARGE
+ default "r6in.4xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_4XLARGE
+ default "r6in.8xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_8XLARGE
+ default "r6in.12xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_12XLARGE
+ default "r6in.16xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_16XLARGE
+ default "r6in.24xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_24XLARGE
+ default "r6in.metal" if TERRAFORM_AWS_INSTANCE_R6IN_METAL
+ default "r6in.32xlarge" if TERRAFORM_AWS_INSTANCE_R6IN_32XLARGE
+ default "r6in.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r7a.static b/terraform/aws/kconfigs/instance-types/Kconfig.r7a.static
new file mode 100644
index 00000000..3c8a3e61
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r7a.static
@@ -0,0 +1,122 @@
+# AWS R7A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R7A family"
+ default TERRAFORM_AWS_INSTANCE_R7A_MEDIUM
+ help
+ Select the specific instance size within the R7A family.
+
+config TERRAFORM_AWS_INSTANCE_R7A_MEDIUM
+ bool "r7a.medium"
+ help
+ vCPUs: 1
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_LARGE
+ bool "r7a.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_XLARGE
+ bool "r7a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_2XLARGE
+ bool "r7a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_4XLARGE
+ bool "r7a.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_8XLARGE
+ bool "r7a.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_12XLARGE
+ bool "r7a.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_16XLARGE
+ bool "r7a.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_24XLARGE
+ bool "r7a.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_32XLARGE
+ bool "r7a.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_METAL_48XL
+ bool "r7a.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7A_48XLARGE
+ bool "r7a.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R7A_SIZE
+ string
+ default "r7a.medium" if TERRAFORM_AWS_INSTANCE_R7A_MEDIUM
+ default "r7a.large" if TERRAFORM_AWS_INSTANCE_R7A_LARGE
+ default "r7a.xlarge" if TERRAFORM_AWS_INSTANCE_R7A_XLARGE
+ default "r7a.2xlarge" if TERRAFORM_AWS_INSTANCE_R7A_2XLARGE
+ default "r7a.4xlarge" if TERRAFORM_AWS_INSTANCE_R7A_4XLARGE
+ default "r7a.8xlarge" if TERRAFORM_AWS_INSTANCE_R7A_8XLARGE
+ default "r7a.12xlarge" if TERRAFORM_AWS_INSTANCE_R7A_12XLARGE
+ default "r7a.16xlarge" if TERRAFORM_AWS_INSTANCE_R7A_16XLARGE
+ default "r7a.24xlarge" if TERRAFORM_AWS_INSTANCE_R7A_24XLARGE
+ default "r7a.32xlarge" if TERRAFORM_AWS_INSTANCE_R7A_32XLARGE
+ default "r7a.metal-48xl" if TERRAFORM_AWS_INSTANCE_R7A_METAL_48XL
+ default "r7a.48xlarge" if TERRAFORM_AWS_INSTANCE_R7A_48XLARGE
+ default "r7a.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r7g.static b/terraform/aws/kconfigs/instance-types/Kconfig.r7g.static
new file mode 100644
index 00000000..6163a2f9
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r7g.static
@@ -0,0 +1,95 @@
+# AWS R7G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R7G family"
+ default TERRAFORM_AWS_INSTANCE_R7G_MEDIUM
+ help
+ Select the specific instance size within the R7G family.
+
+config TERRAFORM_AWS_INSTANCE_R7G_MEDIUM
+ bool "r7g.medium"
+ help
+ vCPUs: 1
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_LARGE
+ bool "r7g.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_XLARGE
+ bool "r7g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_2XLARGE
+ bool "r7g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_4XLARGE
+ bool "r7g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_8XLARGE
+ bool "r7g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_12XLARGE
+ bool "r7g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_METAL
+ bool "r7g.metal"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7G_16XLARGE
+ bool "r7g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R7G_SIZE
+ string
+ default "r7g.medium" if TERRAFORM_AWS_INSTANCE_R7G_MEDIUM
+ default "r7g.large" if TERRAFORM_AWS_INSTANCE_R7G_LARGE
+ default "r7g.xlarge" if TERRAFORM_AWS_INSTANCE_R7G_XLARGE
+ default "r7g.2xlarge" if TERRAFORM_AWS_INSTANCE_R7G_2XLARGE
+ default "r7g.4xlarge" if TERRAFORM_AWS_INSTANCE_R7G_4XLARGE
+ default "r7g.8xlarge" if TERRAFORM_AWS_INSTANCE_R7G_8XLARGE
+ default "r7g.12xlarge" if TERRAFORM_AWS_INSTANCE_R7G_12XLARGE
+ default "r7g.metal" if TERRAFORM_AWS_INSTANCE_R7G_METAL
+ default "r7g.16xlarge" if TERRAFORM_AWS_INSTANCE_R7G_16XLARGE
+ default "r7g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r7gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.r7gd.static
new file mode 100644
index 00000000..f05f2498
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r7gd.static
@@ -0,0 +1,104 @@
+# AWS R7GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R7GD family"
+ default TERRAFORM_AWS_INSTANCE_R7GD_MEDIUM
+ help
+ Select the specific instance size within the R7GD family.
+
+config TERRAFORM_AWS_INSTANCE_R7GD_MEDIUM
+ bool "r7gd.medium"
+ help
+ vCPUs: 1
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_LARGE
+ bool "r7gd.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_XLARGE
+ bool "r7gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_2XLARGE
+ bool "r7gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_4XLARGE
+ bool "r7gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_8XLARGE
+ bool "r7gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_12XLARGE
+ bool "r7gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_16XLARGE
+ bool "r7gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_R7GD_METAL
+ bool "r7gd.metal"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_R7GD_SIZE
+ string
+ default "r7gd.medium" if TERRAFORM_AWS_INSTANCE_R7GD_MEDIUM
+ default "r7gd.large" if TERRAFORM_AWS_INSTANCE_R7GD_LARGE
+ default "r7gd.xlarge" if TERRAFORM_AWS_INSTANCE_R7GD_XLARGE
+ default "r7gd.2xlarge" if TERRAFORM_AWS_INSTANCE_R7GD_2XLARGE
+ default "r7gd.4xlarge" if TERRAFORM_AWS_INSTANCE_R7GD_4XLARGE
+ default "r7gd.8xlarge" if TERRAFORM_AWS_INSTANCE_R7GD_8XLARGE
+ default "r7gd.12xlarge" if TERRAFORM_AWS_INSTANCE_R7GD_12XLARGE
+ default "r7gd.16xlarge" if TERRAFORM_AWS_INSTANCE_R7GD_16XLARGE
+ default "r7gd.metal" if TERRAFORM_AWS_INSTANCE_R7GD_METAL
+ default "r7gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r7i.static b/terraform/aws/kconfigs/instance-types/Kconfig.r7i.static
new file mode 100644
index 00000000..792e1f86
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r7i.static
@@ -0,0 +1,113 @@
+# AWS R7I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R7I family"
+ default TERRAFORM_AWS_INSTANCE_R7I_LARGE
+ help
+ Select the specific instance size within the R7I family.
+
+config TERRAFORM_AWS_INSTANCE_R7I_LARGE
+ bool "r7i.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_XLARGE
+ bool "r7i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_2XLARGE
+ bool "r7i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_4XLARGE
+ bool "r7i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_8XLARGE
+ bool "r7i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_12XLARGE
+ bool "r7i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 18.75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_16XLARGE
+ bool "r7i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_METAL_24XL
+ bool "r7i.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_24XLARGE
+ bool "r7i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 37.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_METAL_48XL
+ bool "r7i.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7I_48XLARGE
+ bool "r7i.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R7I_SIZE
+ string
+ default "r7i.large" if TERRAFORM_AWS_INSTANCE_R7I_LARGE
+ default "r7i.xlarge" if TERRAFORM_AWS_INSTANCE_R7I_XLARGE
+ default "r7i.2xlarge" if TERRAFORM_AWS_INSTANCE_R7I_2XLARGE
+ default "r7i.4xlarge" if TERRAFORM_AWS_INSTANCE_R7I_4XLARGE
+ default "r7i.8xlarge" if TERRAFORM_AWS_INSTANCE_R7I_8XLARGE
+ default "r7i.12xlarge" if TERRAFORM_AWS_INSTANCE_R7I_12XLARGE
+ default "r7i.16xlarge" if TERRAFORM_AWS_INSTANCE_R7I_16XLARGE
+ default "r7i.metal-24xl" if TERRAFORM_AWS_INSTANCE_R7I_METAL_24XL
+ default "r7i.24xlarge" if TERRAFORM_AWS_INSTANCE_R7I_24XLARGE
+ default "r7i.metal-48xl" if TERRAFORM_AWS_INSTANCE_R7I_METAL_48XL
+ default "r7i.48xlarge" if TERRAFORM_AWS_INSTANCE_R7I_48XLARGE
+ default "r7i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r7iz.static b/terraform/aws/kconfigs/instance-types/Kconfig.r7iz.static
new file mode 100644
index 00000000..38b4e813
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r7iz.static
@@ -0,0 +1,104 @@
+# AWS R7IZ instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R7IZ family"
+ default TERRAFORM_AWS_INSTANCE_R7IZ_LARGE
+ help
+ Select the specific instance size within the R7IZ family.
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_LARGE
+ bool "r7iz.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_XLARGE
+ bool "r7iz.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_2XLARGE
+ bool "r7iz.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_4XLARGE
+ bool "r7iz.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_8XLARGE
+ bool "r7iz.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_12XLARGE
+ bool "r7iz.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_16XLARGE
+ bool "r7iz.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_METAL_16XL
+ bool "r7iz.metal-16xl"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_32XLARGE
+ bool "r7iz.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R7IZ_METAL_32XL
+ bool "r7iz.metal-32xl"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R7IZ_SIZE
+ string
+ default "r7iz.large" if TERRAFORM_AWS_INSTANCE_R7IZ_LARGE
+ default "r7iz.xlarge" if TERRAFORM_AWS_INSTANCE_R7IZ_XLARGE
+ default "r7iz.2xlarge" if TERRAFORM_AWS_INSTANCE_R7IZ_2XLARGE
+ default "r7iz.4xlarge" if TERRAFORM_AWS_INSTANCE_R7IZ_4XLARGE
+ default "r7iz.8xlarge" if TERRAFORM_AWS_INSTANCE_R7IZ_8XLARGE
+ default "r7iz.12xlarge" if TERRAFORM_AWS_INSTANCE_R7IZ_12XLARGE
+ default "r7iz.16xlarge" if TERRAFORM_AWS_INSTANCE_R7IZ_16XLARGE
+ default "r7iz.metal-16xl" if TERRAFORM_AWS_INSTANCE_R7IZ_METAL_16XL
+ default "r7iz.32xlarge" if TERRAFORM_AWS_INSTANCE_R7IZ_32XLARGE
+ default "r7iz.metal-32xl" if TERRAFORM_AWS_INSTANCE_R7IZ_METAL_32XL
+ default "r7iz.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r8g.static b/terraform/aws/kconfigs/instance-types/Kconfig.r8g.static
new file mode 100644
index 00000000..8b12d614
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r8g.static
@@ -0,0 +1,122 @@
+# AWS R8G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R8G family"
+ default TERRAFORM_AWS_INSTANCE_R8G_MEDIUM
+ help
+ Select the specific instance size within the R8G family.
+
+config TERRAFORM_AWS_INSTANCE_R8G_MEDIUM
+ bool "r8g.medium"
+ help
+ vCPUs: 1
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_LARGE
+ bool "r8g.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_XLARGE
+ bool "r8g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_2XLARGE
+ bool "r8g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_4XLARGE
+ bool "r8g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_8XLARGE
+ bool "r8g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_12XLARGE
+ bool "r8g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_16XLARGE
+ bool "r8g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_METAL_24XL
+ bool "r8g.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_24XLARGE
+ bool "r8g.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_48XLARGE
+ bool "r8g.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8G_METAL_48XL
+ bool "r8g.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R8G_SIZE
+ string
+ default "r8g.medium" if TERRAFORM_AWS_INSTANCE_R8G_MEDIUM
+ default "r8g.large" if TERRAFORM_AWS_INSTANCE_R8G_LARGE
+ default "r8g.xlarge" if TERRAFORM_AWS_INSTANCE_R8G_XLARGE
+ default "r8g.2xlarge" if TERRAFORM_AWS_INSTANCE_R8G_2XLARGE
+ default "r8g.4xlarge" if TERRAFORM_AWS_INSTANCE_R8G_4XLARGE
+ default "r8g.8xlarge" if TERRAFORM_AWS_INSTANCE_R8G_8XLARGE
+ default "r8g.12xlarge" if TERRAFORM_AWS_INSTANCE_R8G_12XLARGE
+ default "r8g.16xlarge" if TERRAFORM_AWS_INSTANCE_R8G_16XLARGE
+ default "r8g.metal-24xl" if TERRAFORM_AWS_INSTANCE_R8G_METAL_24XL
+ default "r8g.24xlarge" if TERRAFORM_AWS_INSTANCE_R8G_24XLARGE
+ default "r8g.48xlarge" if TERRAFORM_AWS_INSTANCE_R8G_48XLARGE
+ default "r8g.metal-48xl" if TERRAFORM_AWS_INSTANCE_R8G_METAL_48XL
+ default "r8g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r8gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.r8gd.static
new file mode 100644
index 00000000..bc02015a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r8gd.static
@@ -0,0 +1,134 @@
+# AWS R8GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R8GD family"
+ default TERRAFORM_AWS_INSTANCE_R8GD_MEDIUM
+ help
+ Select the specific instance size within the R8GD family.
+
+config TERRAFORM_AWS_INSTANCE_R8GD_MEDIUM
+ bool "r8gd.medium"
+ help
+ vCPUs: 1
+ Memory: 8.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_LARGE
+ bool "r8gd.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_XLARGE
+ bool "r8gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_2XLARGE
+ bool "r8gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_4XLARGE
+ bool "r8gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_8XLARGE
+ bool "r8gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_12XLARGE
+ bool "r8gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_16XLARGE
+ bool "r8gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_24XLARGE
+ bool "r8gd.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_METAL_24XL
+ bool "r8gd.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+ Instance storage: 5700 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_METAL_48XL
+ bool "r8gd.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 11400 GB
+
+config TERRAFORM_AWS_INSTANCE_R8GD_48XLARGE
+ bool "r8gd.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 11400 GB
+
+endchoice
+
+config TERRAFORM_AWS_R8GD_SIZE
+ string
+ default "r8gd.medium" if TERRAFORM_AWS_INSTANCE_R8GD_MEDIUM
+ default "r8gd.large" if TERRAFORM_AWS_INSTANCE_R8GD_LARGE
+ default "r8gd.xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_XLARGE
+ default "r8gd.2xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_2XLARGE
+ default "r8gd.4xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_4XLARGE
+ default "r8gd.8xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_8XLARGE
+ default "r8gd.12xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_12XLARGE
+ default "r8gd.16xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_16XLARGE
+ default "r8gd.24xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_24XLARGE
+ default "r8gd.metal-24xl" if TERRAFORM_AWS_INSTANCE_R8GD_METAL_24XL
+ default "r8gd.metal-48xl" if TERRAFORM_AWS_INSTANCE_R8GD_METAL_48XL
+ default "r8gd.48xlarge" if TERRAFORM_AWS_INSTANCE_R8GD_48XLARGE
+ default "r8gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r8i-flex.static b/terraform/aws/kconfigs/instance-types/Kconfig.r8i-flex.static
new file mode 100644
index 00000000..690466d5
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r8i-flex.static
@@ -0,0 +1,77 @@
+# AWS R8I-FLEX instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R8I-FLEX family"
+ default TERRAFORM_AWS_INSTANCE_R8I_FLEX_LARGE
+ help
+ Select the specific instance size within the R8I-FLEX family.
+
+config TERRAFORM_AWS_INSTANCE_R8I_FLEX_LARGE
+ bool "r8i-flex.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_FLEX_XLARGE
+ bool "r8i-flex.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_FLEX_2XLARGE
+ bool "r8i-flex.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_FLEX_4XLARGE
+ bool "r8i-flex.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_FLEX_8XLARGE
+ bool "r8i-flex.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_FLEX_12XLARGE
+ bool "r8i-flex.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: Up to 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_FLEX_16XLARGE
+ bool "r8i-flex.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: Up to 30 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R8I_FLEX_SIZE
+ string
+ default "r8i-flex.large" if TERRAFORM_AWS_INSTANCE_R8I_FLEX_LARGE
+ default "r8i-flex.xlarge" if TERRAFORM_AWS_INSTANCE_R8I_FLEX_XLARGE
+ default "r8i-flex.2xlarge" if TERRAFORM_AWS_INSTANCE_R8I_FLEX_2XLARGE
+ default "r8i-flex.4xlarge" if TERRAFORM_AWS_INSTANCE_R8I_FLEX_4XLARGE
+ default "r8i-flex.8xlarge" if TERRAFORM_AWS_INSTANCE_R8I_FLEX_8XLARGE
+ default "r8i-flex.12xlarge" if TERRAFORM_AWS_INSTANCE_R8I_FLEX_12XLARGE
+ default "r8i-flex.16xlarge" if TERRAFORM_AWS_INSTANCE_R8I_FLEX_16XLARGE
+ default "r8i-flex.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.r8i.static b/terraform/aws/kconfigs/instance-types/Kconfig.r8i.static
new file mode 100644
index 00000000..8babc613
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.r8i.static
@@ -0,0 +1,131 @@
+# AWS R8I instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for R8I family"
+ default TERRAFORM_AWS_INSTANCE_R8I_LARGE
+ help
+ Select the specific instance size within the R8I family.
+
+config TERRAFORM_AWS_INSTANCE_R8I_LARGE
+ bool "r8i.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_XLARGE
+ bool "r8i.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_2XLARGE
+ bool "r8i.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_4XLARGE
+ bool "r8i.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_8XLARGE
+ bool "r8i.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 256.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_12XLARGE
+ bool "r8i.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_16XLARGE
+ bool "r8i.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 512.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_24XLARGE
+ bool "r8i.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 768.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_32XLARGE
+ bool "r8i.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_48XLARGE
+ bool "r8i.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_METAL_48XL
+ bool "r8i.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 1536.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_96XLARGE
+ bool "r8i.96xlarge"
+ help
+ vCPUs: 384
+ Memory: 3072.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_R8I_METAL_96XL
+ bool "r8i.metal-96xl"
+ help
+ vCPUs: 384
+ Memory: 3072.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_R8I_SIZE
+ string
+ default "r8i.large" if TERRAFORM_AWS_INSTANCE_R8I_LARGE
+ default "r8i.xlarge" if TERRAFORM_AWS_INSTANCE_R8I_XLARGE
+ default "r8i.2xlarge" if TERRAFORM_AWS_INSTANCE_R8I_2XLARGE
+ default "r8i.4xlarge" if TERRAFORM_AWS_INSTANCE_R8I_4XLARGE
+ default "r8i.8xlarge" if TERRAFORM_AWS_INSTANCE_R8I_8XLARGE
+ default "r8i.12xlarge" if TERRAFORM_AWS_INSTANCE_R8I_12XLARGE
+ default "r8i.16xlarge" if TERRAFORM_AWS_INSTANCE_R8I_16XLARGE
+ default "r8i.24xlarge" if TERRAFORM_AWS_INSTANCE_R8I_24XLARGE
+ default "r8i.32xlarge" if TERRAFORM_AWS_INSTANCE_R8I_32XLARGE
+ default "r8i.48xlarge" if TERRAFORM_AWS_INSTANCE_R8I_48XLARGE
+ default "r8i.metal-48xl" if TERRAFORM_AWS_INSTANCE_R8I_METAL_48XL
+ default "r8i.96xlarge" if TERRAFORM_AWS_INSTANCE_R8I_96XLARGE
+ default "r8i.metal-96xl" if TERRAFORM_AWS_INSTANCE_R8I_METAL_96XL
+ default "r8i.large"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.t1.static b/terraform/aws/kconfigs/instance-types/Kconfig.t1.static
new file mode 100644
index 00000000..db0894b3
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.t1.static
@@ -0,0 +1,23 @@
+# AWS T1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for T1 family"
+ default TERRAFORM_AWS_INSTANCE_T1_MICRO
+ help
+ Select the specific instance size within the T1 family.
+
+config TERRAFORM_AWS_INSTANCE_T1_MICRO
+ bool "t1.micro"
+ help
+ vCPUs: 1
+ Memory: 0.6 GB
+ Network: Very Low
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_T1_SIZE
+ string
+ default "t1.micro" if TERRAFORM_AWS_INSTANCE_T1_MICRO
+ default "t1.micro"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.t2.static b/terraform/aws/kconfigs/instance-types/Kconfig.t2.static
new file mode 100644
index 00000000..048d99f0
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.t2.static
@@ -0,0 +1,77 @@
+# AWS T2 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for T2 family"
+ default TERRAFORM_AWS_INSTANCE_T2_NANO
+ help
+ Select the specific instance size within the T2 family.
+
+config TERRAFORM_AWS_INSTANCE_T2_NANO
+ bool "t2.nano"
+ help
+ vCPUs: 1
+ Memory: 0.5 GB
+ Network: Low to Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T2_MICRO
+ bool "t2.micro"
+ help
+ vCPUs: 1
+ Memory: 1.0 GB
+ Network: Low to Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T2_SMALL
+ bool "t2.small"
+ help
+ vCPUs: 1
+ Memory: 2.0 GB
+ Network: Low to Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T2_MEDIUM
+ bool "t2.medium"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Low to Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T2_LARGE
+ bool "t2.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Low to Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T2_XLARGE
+ bool "t2.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Moderate
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T2_2XLARGE
+ bool "t2.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Moderate
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_T2_SIZE
+ string
+ default "t2.nano" if TERRAFORM_AWS_INSTANCE_T2_NANO
+ default "t2.micro" if TERRAFORM_AWS_INSTANCE_T2_MICRO
+ default "t2.small" if TERRAFORM_AWS_INSTANCE_T2_SMALL
+ default "t2.medium" if TERRAFORM_AWS_INSTANCE_T2_MEDIUM
+ default "t2.large" if TERRAFORM_AWS_INSTANCE_T2_LARGE
+ default "t2.xlarge" if TERRAFORM_AWS_INSTANCE_T2_XLARGE
+ default "t2.2xlarge" if TERRAFORM_AWS_INSTANCE_T2_2XLARGE
+ default "t2.nano"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.t3.static b/terraform/aws/kconfigs/instance-types/Kconfig.t3.static
new file mode 100644
index 00000000..34074cbf
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.t3.static
@@ -0,0 +1,77 @@
+# AWS T3 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for T3 family"
+ default TERRAFORM_AWS_INSTANCE_T3_NANO
+ help
+ Select the specific instance size within the T3 family.
+
+config TERRAFORM_AWS_INSTANCE_T3_NANO
+ bool "t3.nano"
+ help
+ vCPUs: 2
+ Memory: 0.5 GB
+ Network: Up to 5 Gigabit
+ Price: $0.005/hour
+
+config TERRAFORM_AWS_INSTANCE_T3_MICRO
+ bool "t3.micro"
+ help
+ vCPUs: 2
+ Memory: 1.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.010/hour
+
+config TERRAFORM_AWS_INSTANCE_T3_SMALL
+ bool "t3.small"
+ help
+ vCPUs: 2
+ Memory: 2.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.021/hour
+
+config TERRAFORM_AWS_INSTANCE_T3_MEDIUM
+ bool "t3.medium"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.042/hour
+
+config TERRAFORM_AWS_INSTANCE_T3_LARGE
+ bool "t3.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.083/hour
+
+config TERRAFORM_AWS_INSTANCE_T3_XLARGE
+ bool "t3.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.166/hour
+
+config TERRAFORM_AWS_INSTANCE_T3_2XLARGE
+ bool "t3.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.333/hour
+
+endchoice
+
+config TERRAFORM_AWS_T3_SIZE
+ string
+ default "t3.nano" if TERRAFORM_AWS_INSTANCE_T3_NANO
+ default "t3.micro" if TERRAFORM_AWS_INSTANCE_T3_MICRO
+ default "t3.small" if TERRAFORM_AWS_INSTANCE_T3_SMALL
+ default "t3.medium" if TERRAFORM_AWS_INSTANCE_T3_MEDIUM
+ default "t3.large" if TERRAFORM_AWS_INSTANCE_T3_LARGE
+ default "t3.xlarge" if TERRAFORM_AWS_INSTANCE_T3_XLARGE
+ default "t3.2xlarge" if TERRAFORM_AWS_INSTANCE_T3_2XLARGE
+ default "t3.nano"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.t3a.static b/terraform/aws/kconfigs/instance-types/Kconfig.t3a.static
new file mode 100644
index 00000000..0cc56e5d
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.t3a.static
@@ -0,0 +1,77 @@
+# AWS T3A instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for T3A family"
+ default TERRAFORM_AWS_INSTANCE_T3A_NANO
+ help
+ Select the specific instance size within the T3A family.
+
+config TERRAFORM_AWS_INSTANCE_T3A_NANO
+ bool "t3a.nano"
+ help
+ vCPUs: 2
+ Memory: 0.5 GB
+ Network: Up to 5 Gigabit
+ Price: $0.005/hour
+
+config TERRAFORM_AWS_INSTANCE_T3A_MICRO
+ bool "t3a.micro"
+ help
+ vCPUs: 2
+ Memory: 1.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.009/hour
+
+config TERRAFORM_AWS_INSTANCE_T3A_SMALL
+ bool "t3a.small"
+ help
+ vCPUs: 2
+ Memory: 2.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.019/hour
+
+config TERRAFORM_AWS_INSTANCE_T3A_MEDIUM
+ bool "t3a.medium"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.038/hour
+
+config TERRAFORM_AWS_INSTANCE_T3A_LARGE
+ bool "t3a.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.075/hour
+
+config TERRAFORM_AWS_INSTANCE_T3A_XLARGE
+ bool "t3a.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.150/hour
+
+config TERRAFORM_AWS_INSTANCE_T3A_2XLARGE
+ bool "t3a.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 5 Gigabit
+ Price: $0.301/hour
+
+endchoice
+
+config TERRAFORM_AWS_T3A_SIZE
+ string
+ default "t3a.nano" if TERRAFORM_AWS_INSTANCE_T3A_NANO
+ default "t3a.micro" if TERRAFORM_AWS_INSTANCE_T3A_MICRO
+ default "t3a.small" if TERRAFORM_AWS_INSTANCE_T3A_SMALL
+ default "t3a.medium" if TERRAFORM_AWS_INSTANCE_T3A_MEDIUM
+ default "t3a.large" if TERRAFORM_AWS_INSTANCE_T3A_LARGE
+ default "t3a.xlarge" if TERRAFORM_AWS_INSTANCE_T3A_XLARGE
+ default "t3a.2xlarge" if TERRAFORM_AWS_INSTANCE_T3A_2XLARGE
+ default "t3a.nano"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.t4g.static b/terraform/aws/kconfigs/instance-types/Kconfig.t4g.static
new file mode 100644
index 00000000..a5ad471d
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.t4g.static
@@ -0,0 +1,77 @@
+# AWS T4G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for T4G family"
+ default TERRAFORM_AWS_INSTANCE_T4G_NANO
+ help
+ Select the specific instance size within the T4G family.
+
+config TERRAFORM_AWS_INSTANCE_T4G_NANO
+ bool "t4g.nano"
+ help
+ vCPUs: 2
+ Memory: 0.5 GB
+ Network: Up to 5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T4G_MICRO
+ bool "t4g.micro"
+ help
+ vCPUs: 2
+ Memory: 1.0 GB
+ Network: Up to 5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T4G_SMALL
+ bool "t4g.small"
+ help
+ vCPUs: 2
+ Memory: 2.0 GB
+ Network: Up to 5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T4G_MEDIUM
+ bool "t4g.medium"
+ help
+ vCPUs: 2
+ Memory: 4.0 GB
+ Network: Up to 5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T4G_LARGE
+ bool "t4g.large"
+ help
+ vCPUs: 2
+ Memory: 8.0 GB
+ Network: Up to 5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T4G_XLARGE
+ bool "t4g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 16.0 GB
+ Network: Up to 5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_T4G_2XLARGE
+ bool "t4g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 5 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_T4G_SIZE
+ string
+ default "t4g.nano" if TERRAFORM_AWS_INSTANCE_T4G_NANO
+ default "t4g.micro" if TERRAFORM_AWS_INSTANCE_T4G_MICRO
+ default "t4g.small" if TERRAFORM_AWS_INSTANCE_T4G_SMALL
+ default "t4g.medium" if TERRAFORM_AWS_INSTANCE_T4G_MEDIUM
+ default "t4g.large" if TERRAFORM_AWS_INSTANCE_T4G_LARGE
+ default "t4g.xlarge" if TERRAFORM_AWS_INSTANCE_T4G_XLARGE
+ default "t4g.2xlarge" if TERRAFORM_AWS_INSTANCE_T4G_2XLARGE
+ default "t4g.nano"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.trn1.static b/terraform/aws/kconfigs/instance-types/Kconfig.trn1.static
new file mode 100644
index 00000000..0e437117
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.trn1.static
@@ -0,0 +1,34 @@
+# AWS TRN1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for TRN1 family"
+ default TERRAFORM_AWS_INSTANCE_TRN1_2XLARGE
+ help
+ Select the specific instance size within the TRN1 family.
+
+config TERRAFORM_AWS_INSTANCE_TRN1_2XLARGE
+ bool "trn1.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+ Instance storage: 474 GB
+
+config TERRAFORM_AWS_INSTANCE_TRN1_32XLARGE
+ bool "trn1.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 8x 100 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_TRN1_SIZE
+ string
+ default "trn1.2xlarge" if TERRAFORM_AWS_INSTANCE_TRN1_2XLARGE
+ default "trn1.32xlarge" if TERRAFORM_AWS_INSTANCE_TRN1_32XLARGE
+ default "trn1.2xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.trn1n.static b/terraform/aws/kconfigs/instance-types/Kconfig.trn1n.static
new file mode 100644
index 00000000..fa6264ca
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.trn1n.static
@@ -0,0 +1,24 @@
+# AWS TRN1N instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for TRN1N family"
+ default TERRAFORM_AWS_INSTANCE_TRN1N_32XLARGE
+ help
+ Select the specific instance size within the TRN1N family.
+
+config TERRAFORM_AWS_INSTANCE_TRN1N_32XLARGE
+ bool "trn1n.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 512.0 GB
+ Network: 16x 100 Gigabit
+ Price: pricing varies
+ Instance storage: 7600 GB
+
+endchoice
+
+config TERRAFORM_AWS_TRN1N_SIZE
+ string
+ default "trn1n.32xlarge" if TERRAFORM_AWS_INSTANCE_TRN1N_32XLARGE
+ default "trn1n.32xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u-3tb1.static b/terraform/aws/kconfigs/instance-types/Kconfig.u-3tb1.static
new file mode 100644
index 00000000..01360065
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u-3tb1.static
@@ -0,0 +1,23 @@
+# AWS U-3TB1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U-3TB1 family"
+ default TERRAFORM_AWS_INSTANCE_U_3TB1_56XLARGE
+ help
+ Select the specific instance size within the U-3TB1 family.
+
+config TERRAFORM_AWS_INSTANCE_U_3TB1_56XLARGE
+ bool "u-3tb1.56xlarge"
+ help
+ vCPUs: 224
+ Memory: 3072.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U_3TB1_SIZE
+ string
+ default "u-3tb1.56xlarge" if TERRAFORM_AWS_INSTANCE_U_3TB1_56XLARGE
+ default "u-3tb1.56xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u-6tb1.static b/terraform/aws/kconfigs/instance-types/Kconfig.u-6tb1.static
new file mode 100644
index 00000000..3dfe392f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u-6tb1.static
@@ -0,0 +1,32 @@
+# AWS U-6TB1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U-6TB1 family"
+ default TERRAFORM_AWS_INSTANCE_U_6TB1_56XLARGE
+ help
+ Select the specific instance size within the U-6TB1 family.
+
+config TERRAFORM_AWS_INSTANCE_U_6TB1_56XLARGE
+ bool "u-6tb1.56xlarge"
+ help
+ vCPUs: 224
+ Memory: 6144.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_U_6TB1_112XLARGE
+ bool "u-6tb1.112xlarge"
+ help
+ vCPUs: 448
+ Memory: 6144.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U_6TB1_SIZE
+ string
+ default "u-6tb1.56xlarge" if TERRAFORM_AWS_INSTANCE_U_6TB1_56XLARGE
+ default "u-6tb1.112xlarge" if TERRAFORM_AWS_INSTANCE_U_6TB1_112XLARGE
+ default "u-6tb1.56xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u7i-12tb.static b/terraform/aws/kconfigs/instance-types/Kconfig.u7i-12tb.static
new file mode 100644
index 00000000..5fa4f98a
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u7i-12tb.static
@@ -0,0 +1,23 @@
+# AWS U7I-12TB instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U7I-12TB family"
+ default TERRAFORM_AWS_INSTANCE_U7I_12TB_224XLARGE
+ help
+ Select the specific instance size within the U7I-12TB family.
+
+config TERRAFORM_AWS_INSTANCE_U7I_12TB_224XLARGE
+ bool "u7i-12tb.224xlarge"
+ help
+ vCPUs: 896
+ Memory: 12288.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U7I_12TB_SIZE
+ string
+ default "u7i-12tb.224xlarge" if TERRAFORM_AWS_INSTANCE_U7I_12TB_224XLARGE
+ default "u7i-12tb.224xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u7i-6tb.static b/terraform/aws/kconfigs/instance-types/Kconfig.u7i-6tb.static
new file mode 100644
index 00000000..f652564f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u7i-6tb.static
@@ -0,0 +1,23 @@
+# AWS U7I-6TB instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U7I-6TB family"
+ default TERRAFORM_AWS_INSTANCE_U7I_6TB_112XLARGE
+ help
+ Select the specific instance size within the U7I-6TB family.
+
+config TERRAFORM_AWS_INSTANCE_U7I_6TB_112XLARGE
+ bool "u7i-6tb.112xlarge"
+ help
+ vCPUs: 448
+ Memory: 6144.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U7I_6TB_SIZE
+ string
+ default "u7i-6tb.112xlarge" if TERRAFORM_AWS_INSTANCE_U7I_6TB_112XLARGE
+ default "u7i-6tb.112xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u7i-8tb.static b/terraform/aws/kconfigs/instance-types/Kconfig.u7i-8tb.static
new file mode 100644
index 00000000..0c08b8d6
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u7i-8tb.static
@@ -0,0 +1,23 @@
+# AWS U7I-8TB instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U7I-8TB family"
+ default TERRAFORM_AWS_INSTANCE_U7I_8TB_112XLARGE
+ help
+ Select the specific instance size within the U7I-8TB family.
+
+config TERRAFORM_AWS_INSTANCE_U7I_8TB_112XLARGE
+ bool "u7i-8tb.112xlarge"
+ help
+ vCPUs: 448
+ Memory: 8192.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U7I_8TB_SIZE
+ string
+ default "u7i-8tb.112xlarge" if TERRAFORM_AWS_INSTANCE_U7I_8TB_112XLARGE
+ default "u7i-8tb.112xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u7in-16tb.static b/terraform/aws/kconfigs/instance-types/Kconfig.u7in-16tb.static
new file mode 100644
index 00000000..fbae9d55
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u7in-16tb.static
@@ -0,0 +1,23 @@
+# AWS U7IN-16TB instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U7IN-16TB family"
+ default TERRAFORM_AWS_INSTANCE_U7IN_16TB_224XLARGE
+ help
+ Select the specific instance size within the U7IN-16TB family.
+
+config TERRAFORM_AWS_INSTANCE_U7IN_16TB_224XLARGE
+ bool "u7in-16tb.224xlarge"
+ help
+ vCPUs: 896
+ Memory: 16384.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U7IN_16TB_SIZE
+ string
+ default "u7in-16tb.224xlarge" if TERRAFORM_AWS_INSTANCE_U7IN_16TB_224XLARGE
+ default "u7in-16tb.224xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u7in-24tb.static b/terraform/aws/kconfigs/instance-types/Kconfig.u7in-24tb.static
new file mode 100644
index 00000000..1f2ecdfe
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u7in-24tb.static
@@ -0,0 +1,23 @@
+# AWS U7IN-24TB instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U7IN-24TB family"
+ default TERRAFORM_AWS_INSTANCE_U7IN_24TB_224XLARGE
+ help
+ Select the specific instance size within the U7IN-24TB family.
+
+config TERRAFORM_AWS_INSTANCE_U7IN_24TB_224XLARGE
+ bool "u7in-24tb.224xlarge"
+ help
+ vCPUs: 896
+ Memory: 24576.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U7IN_24TB_SIZE
+ string
+ default "u7in-24tb.224xlarge" if TERRAFORM_AWS_INSTANCE_U7IN_24TB_224XLARGE
+ default "u7in-24tb.224xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.u7in-32tb.static b/terraform/aws/kconfigs/instance-types/Kconfig.u7in-32tb.static
new file mode 100644
index 00000000..d473cc83
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.u7in-32tb.static
@@ -0,0 +1,23 @@
+# AWS U7IN-32TB instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for U7IN-32TB family"
+ default TERRAFORM_AWS_INSTANCE_U7IN_32TB_224XLARGE
+ help
+ Select the specific instance size within the U7IN-32TB family.
+
+config TERRAFORM_AWS_INSTANCE_U7IN_32TB_224XLARGE
+ bool "u7in-32tb.224xlarge"
+ help
+ vCPUs: 896
+ Memory: 32768.0 GB
+ Network: 200 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_U7IN_32TB_SIZE
+ string
+ default "u7in-32tb.224xlarge" if TERRAFORM_AWS_INSTANCE_U7IN_32TB_224XLARGE
+ default "u7in-32tb.224xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.vt1.static b/terraform/aws/kconfigs/instance-types/Kconfig.vt1.static
new file mode 100644
index 00000000..3a7ecb08
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.vt1.static
@@ -0,0 +1,41 @@
+# AWS VT1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for VT1 family"
+ default TERRAFORM_AWS_INSTANCE_VT1_3XLARGE
+ help
+ Select the specific instance size within the VT1 family.
+
+config TERRAFORM_AWS_INSTANCE_VT1_3XLARGE
+ bool "vt1.3xlarge"
+ help
+ vCPUs: 12
+ Memory: 24.0 GB
+ Network: 3.12 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_VT1_6XLARGE
+ bool "vt1.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 48.0 GB
+ Network: 6.25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_VT1_24XLARGE
+ bool "vt1.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 192.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_VT1_SIZE
+ string
+ default "vt1.3xlarge" if TERRAFORM_AWS_INSTANCE_VT1_3XLARGE
+ default "vt1.6xlarge" if TERRAFORM_AWS_INSTANCE_VT1_6XLARGE
+ default "vt1.24xlarge" if TERRAFORM_AWS_INSTANCE_VT1_24XLARGE
+ default "vt1.3xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.x1.static b/terraform/aws/kconfigs/instance-types/Kconfig.x1.static
new file mode 100644
index 00000000..340f8c3f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.x1.static
@@ -0,0 +1,34 @@
+# AWS X1 instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for X1 family"
+ default TERRAFORM_AWS_INSTANCE_X1_16XLARGE
+ help
+ Select the specific instance size within the X1 family.
+
+config TERRAFORM_AWS_INSTANCE_X1_16XLARGE
+ bool "x1.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 976.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1920 GB
+
+config TERRAFORM_AWS_INSTANCE_X1_32XLARGE
+ bool "x1.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 1952.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3840 GB
+
+endchoice
+
+config TERRAFORM_AWS_X1_SIZE
+ string
+ default "x1.16xlarge" if TERRAFORM_AWS_INSTANCE_X1_16XLARGE
+ default "x1.32xlarge" if TERRAFORM_AWS_INSTANCE_X1_32XLARGE
+ default "x1.16xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.x1e.static b/terraform/aws/kconfigs/instance-types/Kconfig.x1e.static
new file mode 100644
index 00000000..d4eed1b3
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.x1e.static
@@ -0,0 +1,74 @@
+# AWS X1E instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for X1E family"
+ default TERRAFORM_AWS_INSTANCE_X1E_XLARGE
+ help
+ Select the specific instance size within the X1E family.
+
+config TERRAFORM_AWS_INSTANCE_X1E_XLARGE
+ bool "x1e.xlarge"
+ help
+ vCPUs: 4
+ Memory: 122.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 120 GB
+
+config TERRAFORM_AWS_INSTANCE_X1E_2XLARGE
+ bool "x1e.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 244.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 240 GB
+
+config TERRAFORM_AWS_INSTANCE_X1E_4XLARGE
+ bool "x1e.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 488.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 480 GB
+
+config TERRAFORM_AWS_INSTANCE_X1E_8XLARGE
+ bool "x1e.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 976.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 960 GB
+
+config TERRAFORM_AWS_INSTANCE_X1E_16XLARGE
+ bool "x1e.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 1952.0 GB
+ Network: 10 Gigabit
+ Price: pricing varies
+ Instance storage: 1920 GB
+
+config TERRAFORM_AWS_INSTANCE_X1E_32XLARGE
+ bool "x1e.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 3904.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3840 GB
+
+endchoice
+
+config TERRAFORM_AWS_X1E_SIZE
+ string
+ default "x1e.xlarge" if TERRAFORM_AWS_INSTANCE_X1E_XLARGE
+ default "x1e.2xlarge" if TERRAFORM_AWS_INSTANCE_X1E_2XLARGE
+ default "x1e.4xlarge" if TERRAFORM_AWS_INSTANCE_X1E_4XLARGE
+ default "x1e.8xlarge" if TERRAFORM_AWS_INSTANCE_X1E_8XLARGE
+ default "x1e.16xlarge" if TERRAFORM_AWS_INSTANCE_X1E_16XLARGE
+ default "x1e.32xlarge" if TERRAFORM_AWS_INSTANCE_X1E_32XLARGE
+ default "x1e.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.x2gd.static b/terraform/aws/kconfigs/instance-types/Kconfig.x2gd.static
new file mode 100644
index 00000000..da65a4fa
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.x2gd.static
@@ -0,0 +1,104 @@
+# AWS X2GD instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for X2GD family"
+ default TERRAFORM_AWS_INSTANCE_X2GD_MEDIUM
+ help
+ Select the specific instance size within the X2GD family.
+
+config TERRAFORM_AWS_INSTANCE_X2GD_MEDIUM
+ bool "x2gd.medium"
+ help
+ vCPUs: 1
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 59 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_LARGE
+ bool "x2gd.large"
+ help
+ vCPUs: 2
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_XLARGE
+ bool "x2gd.xlarge"
+ help
+ vCPUs: 4
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_2XLARGE
+ bool "x2gd.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 128.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 475 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_4XLARGE
+ bool "x2gd.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 256.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_8XLARGE
+ bool "x2gd.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 512.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_12XLARGE
+ bool "x2gd.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 768.0 GB
+ Network: 20 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_METAL
+ bool "x2gd.metal"
+ help
+ vCPUs: 64
+ Memory: 1024.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_X2GD_16XLARGE
+ bool "x2gd.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 1024.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_X2GD_SIZE
+ string
+ default "x2gd.medium" if TERRAFORM_AWS_INSTANCE_X2GD_MEDIUM
+ default "x2gd.large" if TERRAFORM_AWS_INSTANCE_X2GD_LARGE
+ default "x2gd.xlarge" if TERRAFORM_AWS_INSTANCE_X2GD_XLARGE
+ default "x2gd.2xlarge" if TERRAFORM_AWS_INSTANCE_X2GD_2XLARGE
+ default "x2gd.4xlarge" if TERRAFORM_AWS_INSTANCE_X2GD_4XLARGE
+ default "x2gd.8xlarge" if TERRAFORM_AWS_INSTANCE_X2GD_8XLARGE
+ default "x2gd.12xlarge" if TERRAFORM_AWS_INSTANCE_X2GD_12XLARGE
+ default "x2gd.metal" if TERRAFORM_AWS_INSTANCE_X2GD_METAL
+ default "x2gd.16xlarge" if TERRAFORM_AWS_INSTANCE_X2GD_16XLARGE
+ default "x2gd.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.x2idn.static b/terraform/aws/kconfigs/instance-types/Kconfig.x2idn.static
new file mode 100644
index 00000000..93f1b2c8
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.x2idn.static
@@ -0,0 +1,54 @@
+# AWS X2IDN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for X2IDN family"
+ default TERRAFORM_AWS_INSTANCE_X2IDN_16XLARGE
+ help
+ Select the specific instance size within the X2IDN family.
+
+config TERRAFORM_AWS_INSTANCE_X2IDN_16XLARGE
+ bool "x2idn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 1024.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IDN_24XLARGE
+ bool "x2idn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 1536.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IDN_METAL
+ bool "x2idn.metal"
+ help
+ vCPUs: 128
+ Memory: 2048.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IDN_32XLARGE
+ bool "x2idn.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 2048.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_X2IDN_SIZE
+ string
+ default "x2idn.16xlarge" if TERRAFORM_AWS_INSTANCE_X2IDN_16XLARGE
+ default "x2idn.24xlarge" if TERRAFORM_AWS_INSTANCE_X2IDN_24XLARGE
+ default "x2idn.metal" if TERRAFORM_AWS_INSTANCE_X2IDN_METAL
+ default "x2idn.32xlarge" if TERRAFORM_AWS_INSTANCE_X2IDN_32XLARGE
+ default "x2idn.16xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.x2iedn.static b/terraform/aws/kconfigs/instance-types/Kconfig.x2iedn.static
new file mode 100644
index 00000000..3ce1afaa
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.x2iedn.static
@@ -0,0 +1,94 @@
+# AWS X2IEDN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for X2IEDN family"
+ default TERRAFORM_AWS_INSTANCE_X2IEDN_XLARGE
+ help
+ Select the specific instance size within the X2IEDN family.
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_XLARGE
+ bool "x2iedn.xlarge"
+ help
+ vCPUs: 4
+ Memory: 128.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 118 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_2XLARGE
+ bool "x2iedn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 256.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 237 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_4XLARGE
+ bool "x2iedn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 512.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+ Instance storage: 475 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_8XLARGE
+ bool "x2iedn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 1024.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 950 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_16XLARGE
+ bool "x2iedn.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 2048.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+ Instance storage: 1900 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_24XLARGE
+ bool "x2iedn.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 3072.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+ Instance storage: 2850 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_METAL
+ bool "x2iedn.metal"
+ help
+ vCPUs: 128
+ Memory: 4096.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+config TERRAFORM_AWS_INSTANCE_X2IEDN_32XLARGE
+ bool "x2iedn.32xlarge"
+ help
+ vCPUs: 128
+ Memory: 4096.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+ Instance storage: 3800 GB
+
+endchoice
+
+config TERRAFORM_AWS_X2IEDN_SIZE
+ string
+ default "x2iedn.xlarge" if TERRAFORM_AWS_INSTANCE_X2IEDN_XLARGE
+ default "x2iedn.2xlarge" if TERRAFORM_AWS_INSTANCE_X2IEDN_2XLARGE
+ default "x2iedn.4xlarge" if TERRAFORM_AWS_INSTANCE_X2IEDN_4XLARGE
+ default "x2iedn.8xlarge" if TERRAFORM_AWS_INSTANCE_X2IEDN_8XLARGE
+ default "x2iedn.16xlarge" if TERRAFORM_AWS_INSTANCE_X2IEDN_16XLARGE
+ default "x2iedn.24xlarge" if TERRAFORM_AWS_INSTANCE_X2IEDN_24XLARGE
+ default "x2iedn.metal" if TERRAFORM_AWS_INSTANCE_X2IEDN_METAL
+ default "x2iedn.32xlarge" if TERRAFORM_AWS_INSTANCE_X2IEDN_32XLARGE
+ default "x2iedn.xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.x2iezn.static b/terraform/aws/kconfigs/instance-types/Kconfig.x2iezn.static
new file mode 100644
index 00000000..948bcd30
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.x2iezn.static
@@ -0,0 +1,68 @@
+# AWS X2IEZN instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for X2IEZN family"
+ default TERRAFORM_AWS_INSTANCE_X2IEZN_2XLARGE
+ help
+ Select the specific instance size within the X2IEZN family.
+
+config TERRAFORM_AWS_INSTANCE_X2IEZN_2XLARGE
+ bool "x2iezn.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 256.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X2IEZN_4XLARGE
+ bool "x2iezn.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 512.0 GB
+ Network: Up to 25 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X2IEZN_6XLARGE
+ bool "x2iezn.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 768.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X2IEZN_8XLARGE
+ bool "x2iezn.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 1024.0 GB
+ Network: 75 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X2IEZN_12XLARGE
+ bool "x2iezn.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 1536.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X2IEZN_METAL
+ bool "x2iezn.metal"
+ help
+ vCPUs: 48
+ Memory: 1536.0 GB
+ Network: 100 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_X2IEZN_SIZE
+ string
+ default "x2iezn.2xlarge" if TERRAFORM_AWS_INSTANCE_X2IEZN_2XLARGE
+ default "x2iezn.4xlarge" if TERRAFORM_AWS_INSTANCE_X2IEZN_4XLARGE
+ default "x2iezn.6xlarge" if TERRAFORM_AWS_INSTANCE_X2IEZN_6XLARGE
+ default "x2iezn.8xlarge" if TERRAFORM_AWS_INSTANCE_X2IEZN_8XLARGE
+ default "x2iezn.12xlarge" if TERRAFORM_AWS_INSTANCE_X2IEZN_12XLARGE
+ default "x2iezn.metal" if TERRAFORM_AWS_INSTANCE_X2IEZN_METAL
+ default "x2iezn.2xlarge"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.x8g.static b/terraform/aws/kconfigs/instance-types/Kconfig.x8g.static
new file mode 100644
index 00000000..e4db024f
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.x8g.static
@@ -0,0 +1,122 @@
+# AWS X8G instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for X8G family"
+ default TERRAFORM_AWS_INSTANCE_X8G_MEDIUM
+ help
+ Select the specific instance size within the X8G family.
+
+config TERRAFORM_AWS_INSTANCE_X8G_MEDIUM
+ bool "x8g.medium"
+ help
+ vCPUs: 1
+ Memory: 16.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_LARGE
+ bool "x8g.large"
+ help
+ vCPUs: 2
+ Memory: 32.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_XLARGE
+ bool "x8g.xlarge"
+ help
+ vCPUs: 4
+ Memory: 64.0 GB
+ Network: Up to 12.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_2XLARGE
+ bool "x8g.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 128.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_4XLARGE
+ bool "x8g.4xlarge"
+ help
+ vCPUs: 16
+ Memory: 256.0 GB
+ Network: Up to 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_8XLARGE
+ bool "x8g.8xlarge"
+ help
+ vCPUs: 32
+ Memory: 512.0 GB
+ Network: 15 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_12XLARGE
+ bool "x8g.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 768.0 GB
+ Network: 22.5 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_16XLARGE
+ bool "x8g.16xlarge"
+ help
+ vCPUs: 64
+ Memory: 1024.0 GB
+ Network: 30 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_24XLARGE
+ bool "x8g.24xlarge"
+ help
+ vCPUs: 96
+ Memory: 1536.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_METAL_24XL
+ bool "x8g.metal-24xl"
+ help
+ vCPUs: 96
+ Memory: 1536.0 GB
+ Network: 40 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_48XLARGE
+ bool "x8g.48xlarge"
+ help
+ vCPUs: 192
+ Memory: 3072.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+config TERRAFORM_AWS_INSTANCE_X8G_METAL_48XL
+ bool "x8g.metal-48xl"
+ help
+ vCPUs: 192
+ Memory: 3072.0 GB
+ Network: 50 Gigabit
+ Price: pricing varies
+
+endchoice
+
+config TERRAFORM_AWS_X8G_SIZE
+ string
+ default "x8g.medium" if TERRAFORM_AWS_INSTANCE_X8G_MEDIUM
+ default "x8g.large" if TERRAFORM_AWS_INSTANCE_X8G_LARGE
+ default "x8g.xlarge" if TERRAFORM_AWS_INSTANCE_X8G_XLARGE
+ default "x8g.2xlarge" if TERRAFORM_AWS_INSTANCE_X8G_2XLARGE
+ default "x8g.4xlarge" if TERRAFORM_AWS_INSTANCE_X8G_4XLARGE
+ default "x8g.8xlarge" if TERRAFORM_AWS_INSTANCE_X8G_8XLARGE
+ default "x8g.12xlarge" if TERRAFORM_AWS_INSTANCE_X8G_12XLARGE
+ default "x8g.16xlarge" if TERRAFORM_AWS_INSTANCE_X8G_16XLARGE
+ default "x8g.24xlarge" if TERRAFORM_AWS_INSTANCE_X8G_24XLARGE
+ default "x8g.metal-24xl" if TERRAFORM_AWS_INSTANCE_X8G_METAL_24XL
+ default "x8g.48xlarge" if TERRAFORM_AWS_INSTANCE_X8G_48XLARGE
+ default "x8g.metal-48xl" if TERRAFORM_AWS_INSTANCE_X8G_METAL_48XL
+ default "x8g.medium"
+
diff --git a/terraform/aws/kconfigs/instance-types/Kconfig.z1d.static b/terraform/aws/kconfigs/instance-types/Kconfig.z1d.static
new file mode 100644
index 00000000..925b53b6
--- /dev/null
+++ b/terraform/aws/kconfigs/instance-types/Kconfig.z1d.static
@@ -0,0 +1,84 @@
+# AWS Z1D instance sizes (dynamically generated)
+
+choice
+ prompt "Instance size for Z1D family"
+ default TERRAFORM_AWS_INSTANCE_Z1D_LARGE
+ help
+ Select the specific instance size within the Z1D family.
+
+config TERRAFORM_AWS_INSTANCE_Z1D_LARGE
+ bool "z1d.large"
+ help
+ vCPUs: 2
+ Memory: 16.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 75 GB
+
+config TERRAFORM_AWS_INSTANCE_Z1D_XLARGE
+ bool "z1d.xlarge"
+ help
+ vCPUs: 4
+ Memory: 32.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 150 GB
+
+config TERRAFORM_AWS_INSTANCE_Z1D_2XLARGE
+ bool "z1d.2xlarge"
+ help
+ vCPUs: 8
+ Memory: 64.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 300 GB
+
+config TERRAFORM_AWS_INSTANCE_Z1D_3XLARGE
+ bool "z1d.3xlarge"
+ help
+ vCPUs: 12
+ Memory: 96.0 GB
+ Network: Up to 10 Gigabit
+ Price: pricing varies
+ Instance storage: 450 GB
+
+config TERRAFORM_AWS_INSTANCE_Z1D_6XLARGE
+ bool "z1d.6xlarge"
+ help
+ vCPUs: 24
+ Memory: 192.0 GB
+ Network: 12 Gigabit
+ Price: pricing varies
+ Instance storage: 900 GB
+
+config TERRAFORM_AWS_INSTANCE_Z1D_12XLARGE
+ bool "z1d.12xlarge"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+config TERRAFORM_AWS_INSTANCE_Z1D_METAL
+ bool "z1d.metal"
+ help
+ vCPUs: 48
+ Memory: 384.0 GB
+ Network: 25 Gigabit
+ Price: pricing varies
+ Instance storage: 1800 GB
+
+endchoice
+
+config TERRAFORM_AWS_Z1D_SIZE
+ string
+ default "z1d.large" if TERRAFORM_AWS_INSTANCE_Z1D_LARGE
+ default "z1d.xlarge" if TERRAFORM_AWS_INSTANCE_Z1D_XLARGE
+ default "z1d.2xlarge" if TERRAFORM_AWS_INSTANCE_Z1D_2XLARGE
+ default "z1d.3xlarge" if TERRAFORM_AWS_INSTANCE_Z1D_3XLARGE
+ default "z1d.6xlarge" if TERRAFORM_AWS_INSTANCE_Z1D_6XLARGE
+ default "z1d.12xlarge" if TERRAFORM_AWS_INSTANCE_Z1D_12XLARGE
+ default "z1d.metal" if TERRAFORM_AWS_INSTANCE_Z1D_METAL
+ default "z1d.large"
+
diff --git a/terraform/lambdalabs/kconfigs/Kconfig.compute.static b/terraform/lambdalabs/kconfigs/Kconfig.compute.static
new file mode 100644
index 00000000..2e0c8490
--- /dev/null
+++ b/terraform/lambdalabs/kconfigs/Kconfig.compute.static
@@ -0,0 +1,195 @@
+# Lambda Labs instance types (dynamically generated with capacity info)
+
+choice
+ prompt "Lambda Labs instance type"
+ default TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_GH200
+ help
+ Select the Lambda Labs instance type for your deployment.
+ These options are dynamically generated from the Lambda Labs API.
+ [Available] = Has capacity in at least one region
+ [No Capacity] = Currently no capacity available
+ Prices shown are on-demand hourly rates in USD.
+
+# Instance types WITH available capacity:
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_GH200
+ bool "gpu_1x_gh200 ($1.49/hr) - 1x GH200 (96 GB) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_EAST_3)
+ help
+ 1x GH200 (96 GB)
+ AVAILABLE in: us-east-3
+ Price: $1.49/hr (on-demand)
+ vCPUs: 64, Memory: 432 GiB, Storage: 4096 GiB
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_H100_PCIE
+ bool "gpu_1x_h100_pcie ($2.49/hr) - 1x H100 (80 GB PCIe) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_WEST_3)
+ help
+ 1x H100 (80 GB PCIe)
+ AVAILABLE in: us-west-3
+ Price: $2.49/hr (on-demand)
+ vCPUs: 26, Memory: 200 GiB, Storage: 1024 GiB
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_H100_SXM5
+ bool "gpu_1x_h100_sxm5 (Price N/A) - 1x H100 (80 GB SXM5) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_SOUTH_2)
+ help
+ 1x H100 (80 GB SXM5)
+ AVAILABLE in: us-south-2
+ Price: Price N/A (on-demand)
+ vCPUs: 26, Memory: 225 GiB, Storage: 2816 GiB
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_2X_H100_SXM5
+ bool "gpu_2x_h100_sxm5 (Price N/A) - 2x H100 (80 GB SXM5) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_SOUTH_2 || TERRAFORM_LAMBDALABS_REGION_US_SOUTH_3)
+ help
+ 2x H100 (80 GB SXM5)
+ AVAILABLE in: us-south-2, us-south-3
+ Price: Price N/A (on-demand)
+ vCPUs: 52, Memory: 450 GiB, Storage: 5632 GiB
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_4X_H100_SXM5
+ bool "gpu_4x_h100_sxm5 (Price N/A) - 4x H100 (80 GB SXM5) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_SOUTH_2)
+ help
+ 4x H100 (80 GB SXM5)
+ AVAILABLE in: us-south-2
+ Price: Price N/A (on-demand)
+ vCPUs: 104, Memory: 900 GiB, Storage: 11264 GiB
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_8X_A100_80GB_SXM4
+ bool "gpu_8x_a100_80gb_sxm4 (Price N/A) - 8x A100 (80 GB SXM4) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_MIDWEST_1 || TERRAFORM_LAMBDALABS_REGION_AUSTRALIA_EAST_1)
+ help
+ 8x A100 (80 GB SXM4)
+ AVAILABLE in: us-midwest-1, australia-east-1
+ Price: Price N/A (on-demand)
+ vCPUs: 240, Memory: 1800 GiB, Storage: 20480 GiB
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_8X_B200_SXM6
+ bool "gpu_8x_b200_sxm6 (Price N/A) - 8x B200 (180 GB SXM6) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_EAST_1)
+ help
+ 8x B200 (180 GB SXM6)
+ AVAILABLE in: us-east-1
+ Price: Price N/A (on-demand)
+ vCPUs: 208, Memory: 2900 GiB, Storage: 22528 GiB
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_8X_V100
+ bool "gpu_8x_v100 ($4.40/hr) - 8x Tesla V100 (16 GB) [AVAILABLE]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL || (TERRAFORM_LAMBDALABS_REGION_US_SOUTH_1)
+ help
+ 8x Tesla V100 (16 GB)
+ AVAILABLE in: us-south-1
+ Price: $4.40/hr (on-demand)
+ vCPUs: 92, Memory: 448 GiB, Storage: 6041 GiB
+
+# Instance types WITHOUT capacity (not recommended):
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_CPU_4X_GENERAL
+ bool "cpu_4x_general (Price N/A) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 4x CPU General (16 GiB)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: Price N/A (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_A10
+ bool "gpu_1x_a10 ($0.75/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 1x A10 (24 GB PCIe)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $0.75/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_A100
+ bool "gpu_1x_a100 ($1.29/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 1x A100 (40 GB PCIe)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $1.29/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_A100_SXM4
+ bool "gpu_1x_a100_sxm4 (Price N/A) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 1x A100 (40 GB SXM4)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: Price N/A (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_A6000
+ bool "gpu_1x_a6000 ($0.80/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 1x A6000 (48 GB)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $0.80/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_1X_RTX6000
+ bool "gpu_1x_rtx6000 ($0.50/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 1x RTX 6000 (24 GB)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $0.50/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_2X_A100
+ bool "gpu_2x_a100 ($2.58/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 2x A100 (40 GB PCIe)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $2.58/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_2X_A6000
+ bool "gpu_2x_a6000 ($1.60/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 2x A6000 (48 GB)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $1.60/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_4X_A100
+ bool "gpu_4x_a100 ($5.16/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 4x A100 (40 GB PCIe)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $5.16/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_4X_A6000
+ bool "gpu_4x_a6000 ($3.20/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 4x A6000 (48 GB)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $3.20/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_8X_A100
+ bool "gpu_8x_a100 ($10.32/hr) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 8x A100 (40 GB SXM4)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: $10.32/hr (on-demand) when available
+
+config TERRAFORM_LAMBDALABS_INSTANCE_TYPE_GPU_8X_H100_SXM5
+ bool "gpu_8x_h100_sxm5 (Price N/A) - [NO CAPACITY]"
+ depends on !TERRAFORM_LAMBDALABS_REGION_MANUAL
+ help
+ 8x H100 (80 GB SXM5)
+ WARNING: Currently NO CAPACITY in any region!
+ This option will fail during provisioning.
+ Price: Price N/A (on-demand) when available
+
+endchoice
diff --git a/terraform/lambdalabs/kconfigs/Kconfig.images.static b/terraform/lambdalabs/kconfigs/Kconfig.images.static
new file mode 100644
index 00000000..e69de29b
diff --git a/terraform/lambdalabs/kconfigs/Kconfig.location.static b/terraform/lambdalabs/kconfigs/Kconfig.location.static
new file mode 100644
index 00000000..8f998efe
--- /dev/null
+++ b/terraform/lambdalabs/kconfigs/Kconfig.location.static
@@ -0,0 +1,59 @@
+# Lambda Labs regions (dynamically generated with capacity info)
+
+choice
+ prompt "Lambda Labs region"
+ default TERRAFORM_LAMBDALABS_REGION_US_SOUTH_2
+ help
+ Select the Lambda Labs region for deployment.
+ Number shows how many instance types have capacity in that region.
+ Choose regions with higher numbers for better availability.
+
+config TERRAFORM_LAMBDALABS_REGION_US_SOUTH_2
+ bool "us-south-2 - Us South 2 [3 types available]"
+ help
+ Region: Us South 2
+ 3 instance types have capacity in this region.
+
+config TERRAFORM_LAMBDALABS_REGION_AUSTRALIA_EAST_1
+ bool "australia-east-1 - Australia East 1 [1 types available]"
+ help
+ Region: Australia East 1
+ 1 instance types have capacity in this region.
+
+config TERRAFORM_LAMBDALABS_REGION_US_EAST_1
+ bool "us-east-1 - US East (Virginia) [1 types available]"
+ help
+ Region: US East (Virginia)
+ 1 instance types have capacity in this region.
+
+config TERRAFORM_LAMBDALABS_REGION_US_EAST_3
+ bool "us-east-3 - Us East 3 [1 types available]"
+ help
+ Region: Us East 3
+ 1 instance types have capacity in this region.
+
+config TERRAFORM_LAMBDALABS_REGION_US_MIDWEST_1
+ bool "us-midwest-1 - US Midwest [1 types available]"
+ help
+ Region: US Midwest
+ 1 instance types have capacity in this region.
+
+config TERRAFORM_LAMBDALABS_REGION_US_SOUTH_1
+ bool "us-south-1 - US South [1 types available]"
+ help
+ Region: US South
+ 1 instance types have capacity in this region.
+
+config TERRAFORM_LAMBDALABS_REGION_US_SOUTH_3
+ bool "us-south-3 - Us South 3 [1 types available]"
+ help
+ Region: Us South 3
+ 1 instance types have capacity in this region.
+
+config TERRAFORM_LAMBDALABS_REGION_US_WEST_3
+ bool "us-west-3 - US West 3 [1 types available]"
+ help
+ Region: US West 3
+ 1 instance types have capacity in this region.
+
+endchoice
--
2.50.1
^ permalink raw reply related [flat|nested] 6+ messages in thread