pangea-aws 0.1.0

data/lib/pangea/resources/aws_emr_cluster/types/class_methods.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module EmrClusterClassMethods
+          def spark_configuration(options = {})
+            {
+              classification: 'spark-defaults',
+              properties: {
+                'spark.dynamicAllocation.enabled' => 'true',
+                'spark.dynamicAllocation.minExecutors' => options[:min_executors]&.to_s || '1',
+                'spark.dynamicAllocation.maxExecutors' => options[:max_executors]&.to_s || '8',
+                'spark.sql.adaptive.enabled' => 'true',
+                'spark.sql.adaptive.coalescePartitions.enabled' => 'true',
+                'spark.serializer' => 'org.apache.spark.serializer.KryoSerializer'
+              }.merge(options[:additional_properties] || {})
+            }
+          end
+
+          def hadoop_configuration(options = {})
+            {
+              classification: 'hadoop-env',
+              configurations: [{
+                classification: 'export',
+                properties: {
+                  'HADOOP_DATANODE_HEAPSIZE' => options[:datanode_heap] || '2048',
+                  'HADOOP_NAMENODE_HEAPSIZE' => options[:namenode_heap] || '2048'
+                }
+              }]
+            }
+          end
+
+          def hive_configuration(options = {})
+            {
+              classification: 'hive-site',
+              properties: {
+                'javax.jdo.option.ConnectionURL' => options[:connection_url] || 'glue_catalog',
+                'hive.metastore.client.factory.class' => 'com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory',
+                'hive.exec.dynamic.partition' => 'true',
+                'hive.exec.dynamic.partition.mode' => 'nonstrict'
+              }.merge(options[:additional_properties] || {})
+            }
+          end
+
+          def instance_group_config(role, instance_type, count, options = {})
+            config = { instance_role: role.upcase, instance_type: instance_type, instance_count: count }
+            config[:bid_price] = options[:spot_price] if options[:spot_price]
+            config[:ebs_config] = options[:ebs_config] if options[:ebs_config]
+            config[:auto_scaling_policy] = options[:auto_scaling_policy] if options[:auto_scaling_policy]
+            config[:name] = options[:name] if options[:name]
+            config
+          end
+
+          def bootstrap_action(name, script_path, args = [])
+            { name: name, path: script_path, args: Array(args) }
+          end
+
+          def workload_configurations
+            {
+              spark_analytics: spark_analytics_config,
+              machine_learning: machine_learning_config,
+              data_engineering: data_engineering_config,
+              interactive_analytics: interactive_analytics_config
+            }
+          end
+
+          private
+
+          def spark_analytics_config
+            { applications: %w[Hadoop Spark Hive Livy], configurations: [spark_configuration(min_executors: 2, max_executors: 20), hive_configuration] }
+          end
+
+          def machine_learning_config
+            {
+              applications: %w[Hadoop Spark JupyterHub MXNet TensorFlow],
+              configurations: [spark_configuration(min_executors: 1, max_executors: 10, additional_properties: {
+                'spark.dynamicAllocation.schedulerBacklogTimeout' => '1s',
+                'spark.dynamicAllocation.sustainedSchedulerBacklogTimeout' => '5s'
+              })]
+            }
+          end
+
+          def data_engineering_config
+            { applications: %w[Hadoop Spark Hive Pig Sqoop Oozie], configurations: [spark_configuration(min_executors: 4, max_executors: 50), hive_configuration, hadoop_configuration] }
+          end
+
+          def interactive_analytics_config
+            {
+              applications: %w[Hadoop Spark Presto Hive JupyterHub Zeppelin],
+              configurations: [spark_configuration(min_executors: 2, max_executors: 15), hive_configuration,
+                               { classification: 'presto-config', properties: { 'query.max-memory' => '50GB', 'query.max-memory-per-node' => '8GB' } }]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_emr_cluster/types/instance_methods.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module EmrClusterInstanceMethods
+          def uses_spark?
+            applications.include?('Spark')
+          end
+
+          def uses_hive?
+            applications.include?('Hive')
+          end
+
+          def uses_presto?
+            applications.include?('Presto') || applications.include?('Trino')
+          end
+
+          def uses_ml_frameworks?
+            (applications & %w[MXNet TensorFlow]).any?
+          end
+
+          def uses_notebooks?
+            (applications & %w[JupyterHub Zeppelin]).any?
+          end
+
+          def is_multi_az?
+            ec2_attributes[:subnet_ids]&.size.to_i > 1
+          end
+
+          def uses_spot_instances?
+            return true if core_instance_group&.dig(:bid_price)
+            task_instance_groups.any? { |group| group[:bid_price] }
+          end
+
+          def has_auto_scaling?
+            task_instance_groups.any? { |group| group[:auto_scaling_policy] }
+          end
+
+          def total_core_instances
+            core_instance_group&.dig(:instance_count) || 0
+          end
+
+          def total_task_instances
+            task_instance_groups.sum { |group| group[:instance_count] }
+          end
+
+          def total_cluster_instances
+            1 + total_core_instances + total_task_instances
+          end
+
+          def estimated_hourly_cost_usd
+            base_costs = instance_cost_map
+            total = calculate_master_cost(base_costs) + calculate_core_cost(base_costs) + calculate_task_cost(base_costs)
+            total *= 0.3 if uses_spot_instances?
+            total.round(4)
+          end
+
+          def configuration_warnings
+            warnings = []
+            warnings << 'Very large cluster (>1000 instances) may face resource limits' if total_cluster_instances > 1000
+            warnings << 'Consider adding Spark for better performance on most workloads' unless uses_spark?
+            warnings << 'Consider enabling cluster logging for troubleshooting' unless log_uri
+            warnings << 'Consider enabling termination protection for production clusters' if !termination_protection && !uses_spot_instances?
+            warnings << 'Consider configuring auto scaling for task instance groups' if task_instance_groups.any? && !has_auto_scaling?
+            warnings << 'Consider multi-AZ deployment for notebook high availability' if uses_notebooks? && !is_multi_az?
+            warnings
+          end
+
+          private
+
+          def instance_cost_map
+            { 'm5.xlarge' => 0.192, 'm5.2xlarge' => 0.384, 'm5.4xlarge' => 0.768, 'm5.12xlarge' => 2.304,
+              'c5.xlarge' => 0.17, 'c5.2xlarge' => 0.34, 'c5.4xlarge' => 0.68,
+              'r5.xlarge' => 0.252, 'r5.2xlarge' => 0.504, 'r5.4xlarge' => 1.008 }
+          end
+
+          def calculate_master_cost(costs)
+            costs[master_instance_group[:instance_type]] || 0.20
+          end
+
+          def calculate_core_cost(costs)
+            return 0.0 unless core_instance_group
+
+            cost = costs[core_instance_group[:instance_type]] || 0.20
+            cost * (core_instance_group[:instance_count] || 1)
+          end
+
+          def calculate_task_cost(costs)
+            task_instance_groups.sum do |group|
+              (costs[group[:instance_type]] || 0.20) * group[:instance_count]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_emr_cluster/types/validation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module EmrClusterValidation
+          def validate_cluster_name(name)
+            raise Dry::Struct::Error, 'Cluster name must start with letter or underscore and contain only alphanumeric characters, underscores, and hyphens' unless name =~ /\A[a-zA-Z_][a-zA-Z0-9_-]*\z/
+            raise Dry::Struct::Error, 'Cluster name must be 256 characters or less' if name.length > 256
+          end
+
+          def validate_release_label(label)
+            raise Dry::Struct::Error, 'Release label must be in format emr-x.x.x' unless label =~ /\Aemr-\d+\.\d+\.\d+\z/
+          end
+
+          def validate_service_role(role)
+            raise Dry::Struct::Error, 'Service role must be an IAM role ARN or EMR_DefaultRole' unless role.match(/\A(arn:aws:iam::\d{12}:role\/|EMR_DefaultRole)/i)
+          end
+
+          def validate_instance_profile(profile)
+            raise Dry::Struct::Error, 'Instance profile must be an IAM instance profile ARN or EMR_EC2_DefaultRole' unless profile.match(/\A(arn:aws:iam::\d{12}:instance-profile\/|EMR_EC2_DefaultRole)/i)
+          end
+
+          def validate_log_uri(uri)
+            return if uri.nil?
+            raise Dry::Struct::Error, 'Log URI must be an S3 URL (s3://bucket/path)' unless uri.match(/\As3:\/\//)
+          end
+
+          def validate_subnet_config(ec2_attrs)
+            raise Dry::Struct::Error, 'Cannot specify both subnet_id and subnet_ids' if ec2_attrs[:subnet_id] && ec2_attrs[:subnet_ids]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_emr_cluster/types.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'pangea/resources/types'
+require_relative 'types/validation'
+require_relative 'types/instance_methods'
+require_relative 'types/class_methods'
+require_relative 'types/attributes'

data/lib/pangea/resources/aws_emr_cluster/types.rbs

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pangea
+  module Resources
+    module AWS
+      class EmrClusterAttributes < Dry::Struct
+        @attributes: Hash[Symbol, untyped]
+        
+        attr_reader name: String
+        attr_reader release_label: String
+        attr_reader applications: Array[String]
+        attr_reader service_role: String
+        attr_reader configurations: Array[Hash[Symbol, untyped]]
+        attr_reader ec2_attributes: Hash[Symbol, untyped]
+        attr_reader master_instance_group: Hash[Symbol, untyped]
+        attr_reader core_instance_group: Hash[Symbol, untyped]?
+        attr_reader task_instance_groups: Array[Hash[Symbol, untyped]]
+        attr_reader bootstrap_action: Array[Hash[Symbol, untyped]]
+        attr_reader log_uri: String?
+        attr_reader log_encryption_kms_key_id: String?
+        attr_reader termination_protection: bool
+        attr_reader keep_job_flow_alive_when_no_steps: bool
+        attr_reader visible_to_all_users: bool
+        attr_reader auto_termination_policy: Hash[Symbol, Integer?]?
+        attr_reader custom_ami_id: String?
+        attr_reader ebs_root_volume_size: Integer?
+        attr_reader kerberos_attributes: Hash[Symbol, String?]?
+        attr_reader step_concurrency_level: Integer?
+        attr_reader placement_group_configs: Array[Hash[Symbol, String?]]
+        attr_reader tags: Hash[Symbol, String]
+        
+        def self.new: (Hash[Symbol, untyped] attributes) -> EmrClusterAttributes
+        
+        # Application query methods
+        def uses_spark?: () -> bool
+        def uses_hive?: () -> bool
+        def uses_presto?: () -> bool
+        def uses_ml_frameworks?: () -> bool
+        def uses_notebooks?: () -> bool
+        
+        # Configuration query methods
+        def is_multi_az?: () -> bool
+        def uses_spot_instances?: () -> bool
+        def has_auto_scaling?: () -> bool
+        
+        # Instance counting methods
+        def total_core_instances: () -> Integer
+        def total_task_instances: () -> Integer
+        def total_cluster_instances: () -> Integer
+        
+        # Cost and optimization
+        def estimated_hourly_cost_usd: () -> Float
+        def configuration_warnings: () -> Array[String]
+        
+        # Class methods for configuration helpers
+        def self.spark_configuration: (?Hash[Symbol, untyped] options) -> Hash[Symbol, untyped]
+        def self.hadoop_configuration: (?Hash[Symbol, untyped] options) -> Hash[Symbol, untyped]
+        def self.hive_configuration: (?Hash[Symbol, untyped] options) -> Hash[Symbol, untyped]
+        def self.instance_group_config: (String role, String instance_type, Integer count, ?Hash[Symbol, untyped] options) -> Hash[Symbol, untyped]
+        def self.bootstrap_action: (String name, String script_path, ?Array[String] args) -> Hash[Symbol, untyped]
+        def self.workload_configurations: () -> Hash[Symbol, Hash[Symbol, untyped]]
+        
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_emr_instance_group/resource.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'pangea/resources/base'
+require 'pangea/resources/reference'
+require 'pangea/resources/aws_emr_instance_group/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS EMR Instance Group with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] EMR Instance Group attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_emr_instance_group(name, attributes = {})
+        # Validate attributes using dry-struct
+        group_attrs = Types::EmrInstanceGroupAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_emr_instance_group, name) do
+          # Required attributes
+          cluster_id group_attrs.cluster_id
+          instance_role group_attrs.instance_role
+          instance_type group_attrs.instance_type
+          instance_count group_attrs.instance_count
+          
+          # Optional attributes
+          name group_attrs.name if group_attrs.name
+          bid_price group_attrs.bid_price if group_attrs.bid_price
+          
+          # EBS configuration
+          if group_attrs.ebs_config
+            ebs_config do
+              ebs_cfg = group_attrs.ebs_config
+              ebs_optimized ebs_cfg[:ebs_optimized] unless ebs_cfg[:ebs_optimized].nil?
+              
+              if ebs_cfg[:ebs_block_device_config]&.any?
+                ebs_cfg[:ebs_block_device_config].each do |device_config|
+                  ebs_block_device_config do
+                    volumes_per_instance device_config[:volumes_per_instance] if device_config[:volumes_per_instance]
+                    
+                    volume_specification do
+                      vol_spec = device_config[:volume_specification]
+                      volume_type vol_spec[:volume_type]
+                      size_in_gb vol_spec[:size_in_gb]
+                      iops vol_spec[:iops] if vol_spec[:iops]
+                    end
+                  end
+                end
+              end
+            end
+          end
+          
+          # Auto scaling policy
+          if group_attrs.auto_scaling_policy
+            auto_scaling_policy do
+              asp = group_attrs.auto_scaling_policy
+              
+              constraints do
+                constraints_config = asp[:constraints]
+                min_capacity constraints_config[:min_capacity]
+                max_capacity constraints_config[:max_capacity]
+              end
+              
+              asp[:rules].each do |rule|
+                rules do
+                  name rule[:name]
+                  description rule[:description] if rule[:description]
+                  
+                  action do
+                    action_config = rule[:action]
+                    market action_config[:market] if action_config[:market]
+                    
+                    simple_scaling_policy_configuration do
+                      sspc = action_config[:simple_scaling_policy_configuration]
+                      adjustment_type sspc[:adjustment_type] if sspc[:adjustment_type]
+                      scaling_adjustment sspc[:scaling_adjustment]
+                      cool_down sspc[:cool_down] if sspc[:cool_down]
+                    end
+                  end
+                  
+                  trigger do
+                    cloud_watch_alarm_definition do
+                      cwad = rule[:trigger][:cloud_watch_alarm_definition]
+                      comparison_operator cwad[:comparison_operator]
+                      evaluation_periods cwad[:evaluation_periods]
+                      metric_name cwad[:metric_name]
+                      namespace cwad[:namespace]
+                      period cwad[:period]
+                      statistic cwad[:statistic] if cwad[:statistic]
+                      threshold cwad[:threshold]
+                      unit cwad[:unit] if cwad[:unit]
+                      
+                      if cwad[:dimensions]&.any?
+                        dimensions do
+                          cwad[:dimensions].each do |dim_key, dim_value|
+                            public_send(dim_key.to_s.gsub(/[^a-zA-Z0-9_]/, '_').downcase, dim_value)
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          
+          # Configurations
+          group_attrs.configurations.each do |config|
+            configurations do
+              classification config[:classification]
+              
+              if config[:configurations]
+                config[:configurations].each do |sub_config|
+                  configurations do
+                    classification sub_config[:classification] if sub_config[:classification]
+                    
+                    if sub_config[:properties]&.any?
+                      properties do
+                        sub_config[:properties].each do |key, value|
+                          public_send(key.to_s.gsub(/[^a-zA-Z0-9_]/, '_').downcase, value)
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+              
+              if config[:properties]&.any?
+                properties do
+                  config[:properties].each do |key, value|
+                    public_send(key.to_s.gsub(/[^a-zA-Z0-9_]/, '_').downcase, value)
+                  end
+                end
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_emr_instance_group',
+          name: name,
+          resource_attributes: group_attrs.to_h,
+          outputs: {
+            id: "${aws_emr_instance_group.#{name}.id}",
+            running_instance_count: "${aws_emr_instance_group.#{name}.running_instance_count}",
+            status: "${aws_emr_instance_group.#{name}.status}"
+          },
+          computed_properties: {
+            is_master: group_attrs.is_master?,
+            is_core: group_attrs.is_core?,
+            is_task: group_attrs.is_task?,
+            uses_spot_instances: group_attrs.uses_spot_instances?,
+            has_auto_scaling: group_attrs.has_auto_scaling?,
+            is_ebs_optimized: group_attrs.is_ebs_optimized?,
+            total_ebs_storage_gb_per_instance: group_attrs.total_ebs_storage_gb_per_instance,
+            scaling_capacity_range: group_attrs.scaling_capacity_range,
+            scaling_rules_summary: group_attrs.scaling_rules_summary,
+            estimated_hourly_cost_usd: group_attrs.estimated_hourly_cost_usd,
+            configuration_warnings: group_attrs.configuration_warnings
+          }
+        )
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_emr_instance_group/types/attributes.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        class EmrInstanceGroupAttributes < Pangea::Resources::BaseAttributes
+          attribute? :name, Resources::Types::String.optional
+          attribute? :cluster_id, Resources::Types::String.optional
+          attribute? :instance_role, Resources::Types::String.constrained(included_in: ['MASTER', 'CORE', 'TASK']).optional
+          attribute? :instance_type, Resources::Types::String.optional
+          attribute :instance_count, Resources::Types::Integer.constrained(gteq: 1).default(1)
+          attribute? :bid_price, Resources::Types::String.optional
+          attribute :ebs_config, Resources::Types::Hash.default({}.freeze)
+          attribute :auto_scaling_policy, Resources::Types::Hash.default({}.freeze)
+          attribute :configurations, Resources::Types::Array.of(Resources::Types::Hash).default([].freeze)
+
+          def self.new(attributes = {})
+            attrs = super(attributes)
+            raise Dry::Struct::Error, 'Cluster ID must be in format j-XXXXXXXXX' unless attrs.cluster_id =~ /\Aj-[A-Z0-9]{8,}\z/
+            raise Dry::Struct::Error, 'Master instance group must have exactly 1 instance' if attrs.instance_role == 'MASTER' && attrs.instance_count != 1
+            validate_auto_scaling(attrs) if attrs.auto_scaling_policy
+            validate_ebs_config(attrs) if attrs.ebs_config&.dig(:ebs_block_device_config)
+            attrs
+          end
+
+          def self.validate_auto_scaling(attrs)
+            constraints = attrs.auto_scaling_policy&.dig(:constraints)
+            raise Dry::Struct::Error, 'min_capacity cannot be greater than max_capacity' if constraints[:min_capacity] > constraints[:max_capacity]
+            raise Dry::Struct::Error, 'Core instance group min_capacity must be at least 1' if attrs.instance_role == 'CORE' && constraints[:min_capacity] < 1
+          end
+
+          def self.validate_ebs_config(attrs)
+            attrs.ebs_config&.dig(:ebs_block_device_config).each do |device_config|
+              vol_spec = device_config[:volume_specification]
+              raise Dry::Struct::Error, 'IOPS must be specified for io1 and io2 volume types' if %w[io1 io2].include?(vol_spec[:volume_type]) && !vol_spec[:iops]
+              raise Dry::Struct::Error, 'IOPS can only be specified for io1, io2, and gp3 volume types' if vol_spec[:iops] && !%w[io1 io2 gp3].include?(vol_spec[:volume_type])
+            end
+          end
+
+          def is_master? = instance_role == 'MASTER'
+          def is_core? = instance_role == 'CORE'
+          def is_task? = instance_role == 'TASK'
+          def uses_spot_instances? = !bid_price.nil?
+          def has_auto_scaling? = auto_scaling_policy && auto_scaling_policy[:rules]&.any?
+          def is_ebs_optimized? = ebs_config&.dig(:ebs_optimized) || false
+
+          def total_ebs_storage_gb_per_instance
+            return 0 unless ebs_config&.dig(:ebs_block_device_config)
+            ebs_config[:ebs_block_device_config].sum do |dc|
+              dc[:volume_specification][:size_in_gb] * (dc[:volumes_per_instance] || 1)
+            end
+          end
+
+          def scaling_capacity_range
+            return { min: instance_count, max: instance_count } unless has_auto_scaling?
+            c = auto_scaling_policy[:constraints]
+            { min: c[:min_capacity], max: c[:max_capacity] }
+          end
+
+          def scaling_rules_summary
+            return {} unless has_auto_scaling?
+            rules = auto_scaling_policy[:rules]
+            { total_rules: rules.size,
+              scale_out_rules: rules.count { |r| r[:action][:simple_scaling_policy_configuration][:scaling_adjustment].positive? },
+              scale_in_rules: rules.count { |r| r[:action][:simple_scaling_policy_configuration][:scaling_adjustment].negative? },
+              metrics_used: rules.map { |r| r[:trigger][:cloud_watch_alarm_definition][:metric_name] }.uniq }
+          end
+
+          INSTANCE_COSTS = { 'm5.large' => 0.096, 'm5.xlarge' => 0.192, 'm5.2xlarge' => 0.384, 'c5.large' => 0.085, 'r5.large' => 0.126 }.freeze
+          def estimated_hourly_cost_usd
+            base = INSTANCE_COSTS[instance_type] || 0.20
+            total = base * instance_count * (uses_spot_instances? ? 0.3 : 1)
+            (total + total_ebs_storage_gb_per_instance * instance_count * 0.0001).round(4)
+          end
+
+          def configuration_warnings
+            warnings = []
+            warnings << 'Using spot instances for master node is not recommended for production' if is_master? && uses_spot_instances?
+            warnings << 'Using spot instances for core nodes may cause data loss' if is_core? && uses_spot_instances?
+            warnings << 'Auto scaling should typically only be used with task instance groups' if has_auto_scaling? && !is_task?
+            warnings
+          end
+        end
+      end
+    end
+  end
+end