RubyGems - pangea - Versions diffs - 0.0.42 → 0.0.45 - Mend

pangea 0.0.42 → 0.0.45

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2040) hide show

data/lib/pangea/components/auto_scaling_web_servers/component.rb ADDED Viewed

@@ -0,0 +1,396 @@
+# 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/components/base'
+require 'pangea/components/auto_scaling_web_servers/types'
+require 'pangea/resources/aws'
+require 'base64'
+module Pangea
+  module Components
+    # Auto Scaling Group for web servers with CPU-based scaling and health checks
+    # Creates a production-ready ASG with launch template, scaling policies, and monitoring
+    def auto_scaling_web_servers(name, attributes = {})
+      include Base
+      include Resources::AWS
+      # Validate and set defaults
+      component_attrs = AutoScalingWebServers::AutoScalingWebServersAttributes.new(attributes)
+      # Generate component-specific tags
+      component_tag_set = component_tags('AutoScalingWebServers', name, component_attrs.tags)
+      resources = {}
+      # Prepare user data
+      user_data_encoded = if component_attrs.user_data_base64
+        component_attrs.user_data_base64
+      elsif component_attrs.user_data
+        Base64.strict_encode64(component_attrs.user_data)
+      else
+        # Default user data script for web servers
+        default_user_data = <<~SCRIPT
+          #!/bin/bash
+          yum update -y
+          yum install -y httpd
+          systemctl start httpd
+          systemctl enable httpd
+          # Create a simple health check endpoint
+          echo '<html><body><h1>Health Check OK</h1></body></html>' > /var/www/html/health
+          # Configure CloudWatch agent for monitoring
+          yum install -y amazon-cloudwatch-agent
+          # Start CloudWatch agent
+          systemctl start amazon-cloudwatch-agent
+          systemctl enable amazon-cloudwatch-agent
+          # Signal Auto Scaling that instance is ready
+          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource AutoScalingGroup --region ${AWS::Region}
+        SCRIPT
+        Base64.strict_encode64(default_user_data)
+      end
+      # Create Launch Template
+      launch_template_ref = aws_launch_template(component_resource_name(name, :launch_template), {
+        name: "#{name}-launch-template",
+        description: "Launch template for #{name} web servers",
+        image_id: component_attrs.ami_id,
+        instance_type: component_attrs.instance_type,
+        key_name: component_attrs.key_name,
+        vpc_security_group_ids: component_attrs.security_group_refs.map(&:id),
+        user_data: user_data_encoded,
+        iam_instance_profile: component_attrs.iam_instance_profile ? {
+          name: component_attrs.iam_instance_profile
+        } : nil,
+        block_device_mappings: component_attrs.block_device_mappings.map do |bdm|
+          {
+            device_name: bdm.device_name,
+            ebs: {
+              volume_type: bdm.volume_type,
+              volume_size: bdm.volume_size,
+              iops: bdm.iops,
+              throughput: bdm.throughput,
+              encrypted: bdm.encrypted,
+              delete_on_termination: bdm.delete_on_termination
+            }.compact
+          }
+        end,
+        metadata_options: component_attrs.metadata_options,
+        monitoring: {
+          enabled: component_attrs.monitoring.enabled
+        },
+        placement: component_attrs.placement_group ? {
+          group_name: component_attrs.placement_group
+        } : nil,
+        tag_specifications: [{
+          resource_type: "instance",
+          tags: component_tag_set.merge({
+            Name: "#{name}-web-server"
+          })
+        }, {
+          resource_type: "volume",
+          tags: component_tag_set.merge({
+            Name: "#{name}-web-server-volume"
+          })
+        }],
+        tags: component_tag_set
+      }.compact)
+      resources[:launch_template] = launch_template_ref
+      # Prepare ASG tags for propagation
+      asg_tags_list = component_attrs.asg_tags.merge(component_tag_set).map do |key, value|
+        {
+          key: key.to_s,
+          value: value.to_s,
+          propagate_at_launch: component_attrs.propagate_at_launch
+        }
+      end
+      # Create Auto Scaling Group
+      asg_attrs = {
+        name: "#{name}-asg",
+        launch_template: {
+          id: launch_template_ref.id,
+          version: "$Latest"
+        },
+        min_size: component_attrs.min_size,
+        max_size: component_attrs.max_size,
+        desired_capacity: component_attrs.desired_capacity,
+        default_cooldown: component_attrs.default_cooldown,
+        health_check_type: component_attrs.health_check_type,
+        health_check_grace_period: component_attrs.health_check_grace_period,
+        vpc_zone_identifier: component_attrs.subnet_refs.map(&:id),
+        availability_zones: component_attrs.availability_zones,
+        target_group_arns: component_attrs.target_group_refs.map(&:arn),
+        load_balancers: component_attrs.load_balancer_names,
+        termination_policies: component_attrs.termination_policies,
+        protect_from_scale_in: component_attrs.protect_from_scale_in,
+        service_linked_role_arn: component_attrs.service_linked_role_arn,
+        enabled_metrics: component_attrs.monitoring.enabled_metrics,
+        tag: asg_tags_list,
+        tags: component_tag_set
+      }.compact
+      # Add mixed instances policy if enabled
+      if component_attrs.enable_mixed_instances && component_attrs.mixed_instances_policy
+        asg_attrs[:mixed_instances_policy] = component_attrs.mixed_instances_policy
+        # Remove launch_template when using mixed instances policy
+        asg_attrs.delete(:launch_template)
+      end
+      # Add warm pool if enabled
+      if component_attrs.enable_warm_pool && component_attrs.warm_pool_config
+        asg_attrs[:warm_pool] = component_attrs.warm_pool_config
+      end
+      asg_ref = aws_autoscaling_group(component_resource_name(name, :asg), asg_attrs)
+      resources[:asg] = asg_ref
+      # Create target group attachments if target groups are provided
+      attachments = {}
+      component_attrs.target_group_refs.each_with_index do |tg_ref, index|
+        attachment_ref = aws_autoscaling_attachment(
+          component_resource_name(name, :attachment, "tg#{index}".to_sym),
+          {
+            autoscaling_group_name: asg_ref.name,
+            alb_target_group_arn: tg_ref.arn
+          }
+        )
+        attachments["tg#{index}".to_sym] = attachment_ref
+      end
+      resources[:attachments] = attachments unless attachments.empty?
+      # Create scaling policies
+      policies = {}
+      alarms = {}
+      # Default CPU scaling policy if enabled
+      if component_attrs.enable_cpu_scaling
+        cpu_policy_ref = aws_autoscaling_policy(component_resource_name(name, :policy, :cpu), {
+          name: "#{name}-cpu-scaling-policy",
+          autoscaling_group_name: asg_ref.name,
+          policy_type: "TargetTrackingScaling",
+          target_tracking_configuration: {
+            target_value: component_attrs.cpu_target_value,
+            predefined_metric_specification: {
+              predefined_metric_type: "ASGAverageCPUUtilization"
+            },
+            scale_out_cooldown: 300,
+            scale_in_cooldown: 300,
+            disable_scale_in: false
+          }
+        })
+        policies[:cpu_scaling] = cpu_policy_ref
+      end
+      # Create custom scaling policies
+      component_attrs.scaling_policies.each_with_index do |policy_config, index|
+        policy_name = "custom_#{index}"
+        case policy_config.policy_type
+        when "TargetTrackingScaling"
+          predefined_metric = case policy_config.metric_type
+          when "ASGAverageCPUUtilization"
+            { predefined_metric_type: "ASGAverageCPUUtilization" }
+          when "ASGAverageNetworkIn"
+            { predefined_metric_type: "ASGAverageNetworkIn" }
+          when "ASGAverageNetworkOut"
+            { predefined_metric_type: "ASGAverageNetworkOut" }
+          when "ALBRequestCountPerTarget"
+            {
+              predefined_metric_type: "ALBRequestCountPerTarget",
+              resource_label: policy_config.target_group_arn
+            }
+          end
+          policy_ref = aws_autoscaling_policy(
+            component_resource_name(name, :policy, policy_name.to_sym),
+            {
+              name: "#{name}-#{policy_name}-policy",
+              autoscaling_group_name: asg_ref.name,
+              policy_type: "TargetTrackingScaling",
+              target_tracking_configuration: {
+                target_value: policy_config.target_value,
+                predefined_metric_specification: predefined_metric,
+                scale_out_cooldown: policy_config.scale_out_cooldown,
+                scale_in_cooldown: policy_config.scale_in_cooldown,
+                disable_scale_in: policy_config.disable_scale_in
+              }.compact
+            }
+          )
+          policies[policy_name.to_sym] = policy_ref
+        when "StepScaling", "SimpleScaling"
+          policy_attrs = {
+            name: "#{name}-#{policy_name}-policy",
+            autoscaling_group_name: asg_ref.name,
+            policy_type: policy_config.policy_type,
+            adjustment_type: policy_config.adjustment_type,
+            cooldown: policy_config.scale_out_cooldown
+          }
+          if policy_config.policy_type == "StepScaling"
+            policy_attrs[:step_adjustments] = policy_config.step_adjustments
+            policy_attrs[:min_adjustment_magnitude] = policy_config.min_adjustment_magnitude
+          else
+            policy_attrs[:scaling_adjustment] = policy_config.scaling_adjustment
+          end
+          policy_ref = aws_autoscaling_policy(
+            component_resource_name(name, :policy, policy_name.to_sym),
+            policy_attrs.compact
+          )
+          policies[policy_name.to_sym] = policy_ref
+        end
+      end
+      resources[:policies] = policies unless policies.empty?
+      # Create CloudWatch alarms for monitoring
+      # CPU Utilization alarm
+      cpu_alarm = aws_cloudwatch_metric_alarm(component_resource_name(name, :alarm, :cpu_high), {
+        alarm_name: "#{name}-asg-cpu-utilization-high",
+        comparison_operator: "GreaterThanThreshold",
+        evaluation_periods: "2",
+        metric_name: "CPUUtilization",
+        namespace: "AWS/EC2",
+        period: "300",
+        statistic: "Average",
+        threshold: "80.0",
+        alarm_description: "ASG CPU utilization is consistently high",
+        dimensions: {
+          AutoScalingGroupName: asg_ref.name
+        },
+        tags: component_tag_set
+      })
+      alarms[:cpu_high] = cpu_alarm
+      # Instance count alarm (ensure minimum instances running)
+      instance_count_alarm = aws_cloudwatch_metric_alarm(component_resource_name(name, :alarm, :instance_count), {
+        alarm_name: "#{name}-asg-instance-count-low",
+        comparison_operator: "LessThanThreshold",
+        evaluation_periods: "2",
+        metric_name: "GroupInServiceInstances",
+        namespace: "AWS/AutoScaling",
+        period: "300",
+        statistic: "Average",
+        threshold: component_attrs.min_size.to_s,
+        alarm_description: "ASG has fewer instances than minimum required",
+        dimensions: {
+          AutoScalingGroupName: asg_ref.name
+        },
+        tags: component_tag_set
+      })
+      alarms[:instance_count] = instance_count_alarm
+      # Network utilization alarm
+      network_alarm = aws_cloudwatch_metric_alarm(component_resource_name(name, :alarm, :network_high), {
+        alarm_name: "#{name}-asg-network-utilization-high",
+        comparison_operator: "GreaterThanThreshold",
+        evaluation_periods: "3",
+        metric_name: "NetworkOut",
+        namespace: "AWS/EC2",
+        period: "300",
+        statistic: "Average",
+        threshold: "100000000", # 100MB
+        alarm_description: "ASG network utilization is high",
+        dimensions: {
+          AutoScalingGroupName: asg_ref.name
+        },
+        tags: component_tag_set
+      })
+      alarms[:network_high] = network_alarm
+      resources[:alarms] = alarms
+      # Create lifecycle hooks if specified
+      hooks = {}
+      component_attrs.lifecycle_hooks.each_with_index do |hook_config, index|
+        hook_ref = aws_autoscaling_lifecycle_hook(
+          component_resource_name(name, :hook, "hook#{index}".to_sym),
+          hook_config.merge({
+            autoscaling_group_name: asg_ref.name
+          })
+        )
+        hooks["hook#{index}".to_sym] = hook_ref
+      end
+      resources[:hooks] = hooks unless hooks.empty?
+      # Calculate outputs
+      outputs = {
+        asg_name: asg_ref.name,
+        asg_arn: asg_ref.arn,
+        launch_template_id: launch_template_ref.id,
+        launch_template_version: launch_template_ref.latest_version,
+        min_size: component_attrs.min_size,
+        max_size: component_attrs.max_size,
+        desired_capacity: component_attrs.desired_capacity || component_attrs.min_size,
+        target_group_arns: component_attrs.target_group_refs.map(&:arn),
+        security_features: [
+          "Encrypted EBS Volumes",
+          "IMDSv2 Required",
+          "Auto Scaling Policies",
+          "CloudWatch Monitoring",
+          ("Health Check Integration" if component_attrs.health_check_type == "ELB"),
+          ("Mixed Instance Types" if component_attrs.enable_mixed_instances),
+          ("Warm Pool" if component_attrs.enable_warm_pool)
+        ].compact,
+        availability_zones: component_attrs.subnet_refs.map { |subnet|
+          # Extract AZ from subnet - this is a simplification
+          subnet.respond_to?(:availability_zone) ? subnet.availability_zone : nil
+        }.compact.uniq,
+        estimated_monthly_cost: (component_attrs.desired_capacity || component_attrs.min_size) * estimate_instance_cost(component_attrs.instance_type)
+      }
+      create_component_reference(
+        'auto_scaling_web_servers',
+        name,
+        component_attrs.to_h,
+        resources,
+        outputs
+      )
+    end
+    private
+    def estimate_instance_cost(instance_type)
+      case instance_type
+      when /^t3\.nano$/
+        4.0
+      when /^t3\.micro$/
+        8.0
+      when /^t3\.small$/
+        16.0
+      when /^t3\.medium$/
+        32.0
+      when /^t3\.large$/
+        64.0
+      when /^c5\.large$/
+        70.0
+      when /^c5\.xlarge$/
+        140.0
+      when /^r5\.large$/
+        100.0
+      else
+        50.0  # Default estimate
+      end
+    end
+  end
+end

data/lib/pangea/components/auto_scaling_web_servers/types.rb ADDED Viewed

@@ -0,0 +1,176 @@
+# 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 'dry-struct'
+require 'pangea/resources/types'
+module Pangea
+  module Components
+    module AutoScalingWebServers
+      # Block device mapping for EBS volumes
+      class BlockDeviceMapping < Dry::Struct
+        transform_keys(&:to_sym)
+        attribute :device_name, Types::String.default("/dev/xvda")
+        attribute :volume_type, Types::EbsVolumeType.default("gp3")
+        attribute :volume_size, Types::Integer.default(20).constrained(gteq: 8, lteq: 16384)
+        attribute :iops, Types::Integer.optional.constrained(gteq: 100, lteq: 16000)
+        attribute :throughput, Types::Integer.optional.constrained(gteq: 125, lteq: 1000)
+        attribute :encrypted, Types::Bool.default(true)
+        attribute :delete_on_termination, Types::Bool.default(true)
+      end
+      # Scaling policy configuration
+      class ScalingPolicyConfig < Dry::Struct
+        transform_keys(&:to_sym)
+        attribute :policy_type, Types::String.default("TargetTrackingScaling").enum('StepScaling', 'TargetTrackingScaling', 'SimpleScaling')
+        attribute :target_value, Types::Coercible::Float.optional.constrained(gt: 0)
+        attribute :metric_type, Types::String.default("ASGAverageCPUUtilization").enum('ASGAverageCPUUtilization', 'ASGAverageNetworkIn', 'ASGAverageNetworkOut', 'ALBRequestCountPerTarget')
+        attribute :scale_out_cooldown, Types::Integer.default(300).constrained(gteq: 0, lteq: 3600)
+        attribute :scale_in_cooldown, Types::Integer.default(300).constrained(gteq: 0, lteq: 3600)
+        attribute :disable_scale_in, Types::Bool.default(false)
+        # For ALB request count per target metric
+        attribute :target_group_arn, Types::String.optional
+        # For step scaling policies
+        attribute :adjustment_type, Types::String.optional.enum('ChangeInCapacity', 'ExactCapacity', 'PercentChangeInCapacity')
+        attribute :step_adjustments, Types::Array.optional.default([].freeze)
+        attribute :min_adjustment_magnitude, Types::Integer.optional
+        # For simple scaling policies
+        attribute :scaling_adjustment, Types::Integer.optional
+      end
+      # Monitoring configuration
+      class MonitoringConfig < Dry::Struct
+        transform_keys(&:to_sym)
+        attribute :enabled, Types::Bool.default(true)
+        attribute :granularity, Types::String.default("1Minute").enum('1Minute')
+        attribute :enabled_metrics, Types::Array.of(Types::String).default([
+          "GroupMinSize",
+          "GroupMaxSize",
+          "GroupDesiredCapacity",
+          "GroupInServiceInstances",
+          "GroupTotalInstances",
+          "GroupPendingInstances",
+          "GroupStandbyInstances",
+          "GroupTerminatingInstances"
+        ].freeze)
+      end
+      # Main Auto Scaling Web Servers component attributes
+      class AutoScalingWebServersAttributes < Dry::Struct
+        transform_keys(&:to_sym)
+        # Network configuration
+        attribute :vpc_ref, Types.Instance(Object)  # ResourceReference to VPC
+        attribute :subnet_refs, Types::Array.of(Types.Instance(Object)).constrained(min_size: 1)  # ResourceReferences to subnets
+        attribute :security_group_refs, Types::Array.of(Types.Instance(Object)).default([].freeze)  # ResourceReferences to security groups
+        # Instance configuration
+        attribute :ami_id, Types::String.constrained(format: /\Aami-[a-f0-9]{8,17}\z/)
+        attribute :instance_type, Types::Ec2InstanceType.default("t3.micro")
+        attribute :key_name, Types::String.optional
+        attribute :iam_instance_profile, Types::String.optional
+        # User data script for instance initialization
+        attribute :user_data, Types::String.optional
+        attribute :user_data_base64, Types::String.optional
+        # Auto Scaling configuration
+        attribute :min_size, Types::Integer.default(1).constrained(gteq: 0, lteq: 1000)
+        attribute :max_size, Types::Integer.default(3).constrained(gteq: 1, lteq: 1000)
+        attribute :desired_capacity, Types::Integer.optional.constrained(gteq: 0, lteq: 1000)
+        attribute :default_cooldown, Types::Integer.default(300).constrained(gteq: 0, lteq: 7200)
+        # Health check configuration
+        attribute :health_check_type, Types::String.default("EC2").enum('EC2', 'ELB')
+        attribute :health_check_grace_period, Types::Integer.default(300).constrained(gteq: 0, lteq: 7200)
+        # Load balancer integration
+        attribute :target_group_refs, Types::Array.of(Types.Instance(Object)).default([].freeze)  # ResourceReferences to target groups
+        attribute :load_balancer_names, Types::Array.of(Types::String).default([].freeze)  # Classic ELB names
+        # Storage configuration
+        attribute :block_device_mappings, Types::Array.of(BlockDeviceMapping).default([
+          BlockDeviceMapping.new(device_name: "/dev/xvda")
+        ].freeze)
+        # Scaling policies
+        attribute :enable_cpu_scaling, Types::Bool.default(true)
+        attribute :cpu_target_value, Types::Coercible::Float.default(70.0).constrained(gteq: 1.0, lteq: 100.0)
+        attribute :scaling_policies, Types::Array.of(ScalingPolicyConfig).default([].freeze)
+        # Instance placement
+        attribute :availability_zones, Types::Array.of(Types::String).optional
+        attribute :placement_group, Types::String.optional
+        # Termination policies
+        attribute :termination_policies, Types::Array.of(Types::String).default([
+          "Default"
+        ].freeze).constructor { |value|
+          valid_policies = [
+            "Default", "OldestInstance", "NewestInstance", "OldestLaunchConfiguration",
+            "OldestLaunchTemplate", "ClosestToNextInstanceHour", "AllocationStrategy"
+          ]
+          invalid_policies = value - valid_policies
+          unless invalid_policies.empty?
+            raise Dry::Types::ConstraintError, "Invalid termination policies: #{invalid_policies.join(', ')}"
+          end
+          value
+        }
+        # Instance protection
+        attribute :protect_from_scale_in, Types::Bool.default(false)
+        # Monitoring
+        attribute :monitoring, MonitoringConfig.default({})
+        # Tags
+        attribute :tags, Types::AwsTags.default({}.freeze)
+        # Auto Scaling group tags (different from resource tags)
+        attribute :asg_tags, Types::Hash.default({}.freeze)
+        attribute :propagate_at_launch, Types::Bool.default(true)
+        # Instance metadata service configuration
+        attribute :metadata_options, Types::Hash.default({
+          http_endpoint: "enabled",
+          http_tokens: "required",
+          http_put_response_hop_limit: 1,
+          instance_metadata_tags: "enabled"
+        }.freeze)
+        # Mixed instances policy for cost optimization
+        attribute :enable_mixed_instances, Types::Bool.default(false)
+        attribute :mixed_instances_policy, Types::Hash.optional
+        # Warm pool configuration
+        attribute :enable_warm_pool, Types::Bool.default(false)
+        attribute :warm_pool_config, Types::Hash.optional
+        # Service-linked role
+        attribute :service_linked_role_arn, Types::String.optional.constrained(format: /\Aarn:aws:iam::\d{12}:role\/aws-service-role\/autoscaling\.amazonaws\.com\/AWSServiceRoleForAutoScaling/)
+        # Lifecycle hooks
+        attribute :lifecycle_hooks, Types::Array.default([].freeze)
+      end
+    end
+  end
+end

data/lib/pangea/components/base.rb ADDED Viewed

@@ -0,0 +1,104 @@
+# 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 Components
+    # Base module for all Pangea components
+    #
+    # Provides common functionality and patterns for component implementations.
+    # Components that include this module get access to helper methods and
+    # standard validation patterns.
+    module Base
+      # Base error class for component-related errors
+      class ComponentError < StandardError; end
+      # Error raised when component validation fails
+      class ValidationError < ComponentError; end
+      # Error raised when component composition fails
+      class CompositionError < ComponentError; end
+      # Validate required attributes are present
+      #
+      # @param attributes [Hash] Input attributes
+      # @param required [Array<Symbol>] Required attribute names
+      # @raise [ValidationError] if any required attributes are missing
+      def validate_required_attributes(attributes, required)
+        missing = required - attributes.keys
+        unless missing.empty?
+          raise ValidationError, "Missing required attributes: #{missing.join(', ')}"
+        end
+      end
+      # Calculate subnet CIDR blocks from a VPC CIDR
+      #
+      # @param vpc_cidr [String] VPC CIDR block (e.g., "10.0.0.0/16")
+      # @param index [Integer] Subnet index
+      # @param new_bits [Integer] Additional bits for subnet mask (default: 8)
+      # @return [String] Subnet CIDR block
+      def calculate_subnet_cidr(vpc_cidr, index, new_bits = 8)
+        require 'ipaddr'
+        vpc_network = IPAddr.new(vpc_cidr)
+        vpc_prefix = vpc_cidr.split('/').last.to_i
+        subnet_prefix = vpc_prefix + new_bits
+        # Calculate the subnet size
+        subnet_size = 2 ** (32 - subnet_prefix)
+        # Calculate the subnet network address
+        subnet_network = vpc_network.to_i + (index * subnet_size)
+        # Return the subnet CIDR
+        "#{IPAddr.new(subnet_network, Socket::AF_INET)}/#{subnet_prefix}"
+      end
+      # Generate consistent naming for component resources
+      #
+      # @param component_name [Symbol, String] Base component name
+      # @param resource_type [Symbol, String] Type of resource
+      # @param suffix [String, nil] Optional suffix
+      # @return [Symbol] Generated resource name
+      def component_resource_name(component_name, resource_type, suffix = nil)
+        parts = [component_name, resource_type]
+        parts << suffix if suffix
+        parts.join('_').to_sym
+      end
+      # Merge default tags with user-provided tags
+      #
+      # @param default_tags [Hash] Default tags to apply
+      # @param user_tags [Hash] User-provided tags (takes precedence)
+      # @return [Hash] Merged tags
+      def merge_tags(default_tags, user_tags = {})
+        default_tags.merge(user_tags)
+      end
+      # Create a component output hash
+      #
+      # @param resources [Hash] Created resources
+      # @param computed [Hash] Computed values
+      # @return [Hash] Combined outputs
+      def component_outputs(resources, computed = {})
+        {
+          resources: resources,
+          computed: computed,
+          created_at: Time.now.utc.iso8601
+        }
+      end
+    end
+  end
+end