pangea 0.0.45 → 0.0.46

data/lib/pangea/components/green_data_lifecycle/types.rb

@@ -1,184 +0,0 @@
-# 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 "dry-types"
-
-module Pangea
-  module Components
-    module GreenDataLifecycle
-      module Types
-        include Dry.Types()
-
-        # Enums for lifecycle strategies
-        LifecycleStrategy = Types::Coercible::String.enum(
-          'access_pattern_based',  # Move based on actual access patterns
-          'time_based',           # Move based on age
-          'size_based',           # Archive large objects first
-          'carbon_optimized',     # Optimize for lowest carbon storage
-          'cost_optimized'        # Optimize for lowest cost
-        )
-
-        StorageClass = Types::Coercible::String.enum(
-          'STANDARD',
-          'INTELLIGENT_TIERING',
-          'STANDARD_IA',
-          'ONEZONE_IA',
-          'GLACIER_IR',
-          'GLACIER_FLEXIBLE',
-          'DEEP_ARCHIVE'
-        )
-
-        DataClassification = Types::Coercible::String.enum(
-          'hot',      # Frequently accessed
-          'warm',     # Occasionally accessed
-          'cool',     # Rarely accessed
-          'cold',     # Archive
-          'frozen'    # Deep archive
-        )
-
-        # Input structure for green data lifecycle
-        class Input < Dry::Struct
-          attribute :name, Types::Strict::String
-          attribute :bucket_prefix, Types::Strict::String.optional.default(nil)
-          
-          # Lifecycle configuration
-          attribute :lifecycle_strategy, LifecycleStrategy.default('carbon_optimized')
-          attribute :enable_intelligent_tiering, Types::Strict::Bool.default(true)
-          attribute :enable_glacier_archive, Types::Strict::Bool.default(true)
-          
-          # Transition rules (days)
-          attribute :transition_to_ia_days, Types::Coercible::Integer.default(30)
-          attribute :transition_to_glacier_ir_days, Types::Coercible::Integer.default(90)
-          attribute :transition_to_glacier_days, Types::Coercible::Integer.default(180)
-          attribute :transition_to_deep_archive_days, Types::Coercible::Integer.default(365)
-          attribute :expire_days, Types::Coercible::Integer.optional.default(nil)
-          
-          # Access pattern configuration
-          attribute :monitor_access_patterns, Types::Strict::Bool.default(true)
-          attribute :access_pattern_window_days, Types::Coercible::Integer.default(90)
-          attribute :optimize_for_read_heavy, Types::Strict::Bool.default(false)
-          
-          # Size-based rules
-          attribute :large_object_threshold_mb, Types::Coercible::Integer.default(100)
-          attribute :archive_large_objects_days, Types::Coercible::Integer.default(7)
-          
-          # Carbon optimization
-          attribute :prefer_renewable_regions, Types::Strict::Bool.default(true)
-          attribute :carbon_threshold_gco2_per_gb, Types::Coercible::Float.default(0.5)
-          
-          # Compliance and governance
-          attribute :compliance_mode, Types::Strict::Bool.default(false)
-          attribute :legal_hold_tags, Types::Array.of(Types::Strict::String).default([])
-          attribute :deletion_protection, Types::Strict::Bool.default(true)
-          
-          # Monitoring
-          attribute :enable_metrics, Types::Strict::Bool.default(true)
-          attribute :enable_inventory, Types::Strict::Bool.default(true)
-          attribute :alert_on_high_storage_carbon, Types::Strict::Bool.default(true)
-          
-          # Tags
-          attribute :tags, Types::Hash.map(Types::Coercible::String, Types::Coercible::String).default({})
-
-          def self.example
-            new(
-              name: "sustainable-data-storage",
-              bucket_prefix: "green-data",
-              lifecycle_strategy: "carbon_optimized",
-              enable_intelligent_tiering: true,
-              monitor_access_patterns: true,
-              prefer_renewable_regions: true,
-              tags: {
-                "Environment" => "production",
-                "Sustainability" => "enabled"
-              }
-            )
-          end
-        end
-
-        # Output structure containing created resources
-        class Output < Dry::Struct
-          # S3 buckets
-          attribute :primary_bucket, Types::Any
-          attribute :archive_bucket, Types::Any.optional
-          
-          # Lifecycle configurations
-          attribute :lifecycle_configuration, Types::Any
-          attribute :intelligent_tiering_configuration, Types::Any.optional
-          
-          # Glacier vault for deep archive
-          attribute :glacier_vault, Types::Any.optional
-          
-          # Lambda functions
-          attribute :access_analyzer_function, Types::Any
-          attribute :carbon_optimizer_function, Types::Any
-          attribute :lifecycle_manager_function, Types::Any
-          
-          # CloudWatch components
-          attribute :storage_metrics, Types::Array.of(Types::Any)
-          attribute :carbon_dashboard, Types::Any
-          attribute :efficiency_alarms, Types::Array.of(Types::Any)
-          
-          # S3 Inventory
-          attribute :inventory_configuration, Types::Any.optional
-          
-          # IAM roles
-          attribute :lifecycle_role, Types::Any
-          attribute :analyzer_role, Types::Any
-          
-          def primary_bucket_name
-            primary_bucket.bucket
-          end
-          
-          def archive_bucket_name
-            archive_bucket&.bucket
-          end
-          
-          def dashboard_url
-            "https://console.aws.amazon.com/cloudwatch/home?region=#{carbon_dashboard.region}#dashboards:name=#{carbon_dashboard.dashboard_name}"
-          end
-        end
-
-        # Carbon intensity by storage class (gCO2/GB/month)
-        STORAGE_CARBON_INTENSITY = {
-          'STANDARD' => 0.55,
-          'INTELLIGENT_TIERING' => 0.45,  # Optimized storage
-          'STANDARD_IA' => 0.35,          # Less active storage
-          'ONEZONE_IA' => 0.30,           # Single AZ
-          'GLACIER_IR' => 0.15,           # Cold storage
-          'GLACIER_FLEXIBLE' => 0.10,     # Archival
-          'DEEP_ARCHIVE' => 0.05          # Tape storage
-        }.freeze
-
-        # Validation methods
-        def self.validate_transition_days(ia, glacier_ir, glacier, deep_archive)
-          raise ArgumentError, "Transition days must be in ascending order" unless ia < glacier_ir && glacier_ir < glacier && glacier < deep_archive
-          raise ArgumentError, "Minimum 30 days before first transition" if ia < 30
-        end
-
-        def self.validate_carbon_threshold(threshold)
-          raise ArgumentError, "Carbon threshold must be positive" if threshold <= 0
-          raise ArgumentError, "Carbon threshold unrealistically low" if threshold < 0.01
-        end
-
-        def self.validate_access_window(window_days)
-          raise ArgumentError, "Access pattern window must be at least 7 days" if window_days < 7
-          raise ArgumentError, "Access pattern window cannot exceed 365 days" if window_days > 365
-        end
-      end
-    end
-  end
-end

data/lib/pangea/components/microservice_deployment/README.md

@@ -1,321 +0,0 @@
-# Microservice Deployment Component
-
-Production-ready ECS microservice deployment with service discovery, circuit breakers, and distributed tracing.
-
-## Overview
-
-The `microservice_deployment` component creates a complete microservice deployment on AWS ECS with enterprise-grade features including:
-
-- **ECS Fargate Service**: Serverless container execution with automatic scaling
-- **Service Discovery**: AWS Cloud Map integration for service-to-service communication
-- **Circuit Breakers**: Deployment circuit breakers for automatic rollback on failures
-- **Distributed Tracing**: X-Ray, Jaeger, or Zipkin integration for observability
-- **Auto-scaling**: CPU and memory-based automatic scaling policies
-- **Health Checks**: Comprehensive health monitoring with CloudWatch alarms
-- **Blue-Green Deployments**: Support for zero-downtime deployments
-
-## Usage
-
-### Basic Microservice
-
-```ruby
-# Create a simple microservice deployment
-service = microservice_deployment(:user_service, {
-  cluster_ref: ecs_cluster_ref,
-  task_definition_family: "user-service",
-  container_definitions: [{
-    name: "user-api",
-    image: "myapp/user-service:latest",
-    cpu: 512,
-    memory: 1024,
-    port_mappings: [{
-      containerPort: 8080,
-      protocol: "tcp"
-    }],
-    environment: [
-      { name: "NODE_ENV", value: "production" },
-      { name: "PORT", value: "8080" }
-    ]
-  }],
-  vpc_ref: vpc_ref,
-  subnet_refs: [private_subnet_a_ref, private_subnet_b_ref],
-  security_group_refs: [service_sg_ref],
-  target_group_refs: [user_service_tg_ref]
-})
-```
-
-### Microservice with Service Discovery
-
-```ruby
-# Create a microservice with service discovery for internal communication
-order_service = microservice_deployment(:order_service, {
-  cluster_ref: ecs_cluster_ref,
-  task_definition_family: "order-service",
-  container_definitions: [{
-    name: "order-api",
-    image: "myapp/order-service:latest",
-    cpu: 1024,
-    memory: 2048,
-    port_mappings: [{
-      containerPort: 3000,
-      protocol: "tcp"
-    }],
-    environment: [
-      { name: "USER_SERVICE_ENDPOINT", value: "user-service.local:8080" }
-    ],
-    health_check: {
-      command: ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"],
-      interval: 30,
-      timeout: 5,
-      retries: 3,
-      startPeriod: 60
-    }
-  }],
-  vpc_ref: vpc_ref,
-  subnet_refs: [private_subnet_a_ref, private_subnet_b_ref],
-  security_group_refs: [service_sg_ref],
-  
-  # Service discovery configuration
-  service_discovery: {
-    namespace_id: service_discovery_namespace_ref.id,
-    service_name: "order-service",
-    dns_config: {
-      routing_policy: "MULTIVALUE",
-      dns_records: [{
-        type: "A",
-        ttl: 60
-      }]
-    }
-  },
-  
-  # Enable auto-scaling
-  auto_scaling: {
-    enabled: true,
-    min_tasks: 2,
-    max_tasks: 10,
-    target_cpu: 70.0,
-    target_memory: 80.0
-  }
-})
-```
-
-### Event-Driven Microservice with Tracing
-
-```ruby
-# Create an event-driven microservice with distributed tracing
-payment_service = microservice_deployment(:payment_service, {
-  cluster_ref: ecs_cluster_ref,
-  task_definition_family: "payment-service",
-  task_cpu: "1024",
-  task_memory: "2048",
-  
-  container_definitions: [{
-    name: "payment-processor",
-    image: "myapp/payment-service:latest",
-    cpu: 896,  # Leave room for X-Ray sidecar
-    memory: 1792,
-    port_mappings: [{
-      containerPort: 8000,
-      protocol: "tcp"
-    }],
-    environment: [
-      { name: "STRIPE_WEBHOOK_ENDPOINT", value: "/webhooks/stripe" },
-      { name: "SQS_QUEUE_URL", value: payment_queue_ref.id }
-    ],
-    secrets: [
-      { name: "STRIPE_API_KEY", valueFrom: stripe_secret_ref.arn },
-      { name: "DATABASE_URL", valueFrom: db_url_secret_ref.arn }
-    ]
-  }],
-  
-  vpc_ref: vpc_ref,
-  subnet_refs: [private_subnet_a_ref, private_subnet_b_ref],
-  security_group_refs: [service_sg_ref],
-  target_group_refs: [payment_service_tg_ref],
-  
-  # Enable distributed tracing
-  tracing: {
-    enabled: true,
-    sampling_rate: 0.1,  # Sample 10% of requests
-    x_ray: true
-  },
-  
-  # Circuit breaker configuration
-  circuit_breaker: {
-    enabled: true,
-    threshold: 5,
-    timeout: 60,
-    rollback: true
-  },
-  
-  # Health check configuration
-  health_check: {
-    path: "/health",
-    interval: 30,
-    timeout: 5,
-    healthy_threshold: 2,
-    unhealthy_threshold: 3,
-    matcher: "200"
-  }
-})
-```
-
-### Multi-Container Microservice
-
-```ruby
-# Create a microservice with multiple containers (main app + sidecar)
-analytics_service = microservice_deployment(:analytics_service, {
-  cluster_ref: ecs_cluster_ref,
-  task_definition_family: "analytics-service",
-  task_cpu: "2048",
-  task_memory: "4096",
-  
-  container_definitions: [
-    {
-      name: "analytics-api",
-      image: "myapp/analytics-api:latest",
-      cpu: 1536,
-      memory: 3072,
-      essential: true,
-      port_mappings: [{
-        containerPort: 5000,
-        protocol: "tcp"
-      }],
-      depends_on: [{
-        containerName: "envoy-proxy",
-        condition: "HEALTHY"
-      }]
-    },
-    {
-      name: "envoy-proxy",
-      image: "envoyproxy/envoy:latest",
-      cpu: 512,
-      memory: 1024,
-      essential: true,
-      port_mappings: [
-        { containerPort: 9901, protocol: "tcp" },  # Admin
-        { containerPort: 15000, protocol: "tcp" }  # Ingress
-      ],
-      health_check: {
-        command: ["CMD-SHELL", "curl -f http://localhost:9901/clusters || exit 1"],
-        interval: 30,
-        timeout: 5,
-        retries: 3
-      }
-    }
-  ],
-  
-  vpc_ref: vpc_ref,
-  subnet_refs: [private_subnet_a_ref, private_subnet_b_ref],
-  security_group_refs: [service_sg_ref],
-  container_name: "envoy-proxy",  # Route traffic through Envoy
-  container_port: 15000,
-  target_group_refs: [analytics_service_tg_ref],
-  
-  # Enable blue-green deployment
-  enable_blue_green: true,
-  deployment_minimum_healthy_percent: 100,
-  deployment_maximum_percent: 200
-})
-```
-
-## Inputs
-
-### Required Inputs
-
-- `cluster_ref`: Reference to the ECS cluster for deployment
-- `task_definition_family`: Name for the task definition family
-- `container_definitions`: Array of container configurations
-- `vpc_ref`: Reference to the VPC
-- `subnet_refs`: Array of subnet references (minimum 2 for HA)
-
-### Optional Inputs
-
-- `security_group_refs`: Security groups for the service (default: [])
-- `assign_public_ip`: Assign public IPs to tasks (default: false)
-- `desired_count`: Number of tasks to run (default: 2)
-- `launch_type`: ECS launch type - FARGATE or EC2 (default: "FARGATE")
-- `task_cpu`: Task CPU units (default: "256")
-- `task_memory`: Task memory in MB (default: "512")
-- `target_group_refs`: Target groups for load balancing (default: [])
-- `service_discovery`: Service discovery configuration (optional)
-- `circuit_breaker`: Circuit breaker configuration
-- `auto_scaling`: Auto-scaling configuration
-- `tracing`: Distributed tracing configuration
-- `health_check`: Health check configuration
-- `enable_blue_green`: Enable blue-green deployments (default: false)
-- `log_retention_days`: CloudWatch log retention (default: 7)
-
-### Container Definition Structure
-
-```ruby
-{
-  name: "container-name",
-  image: "docker-image:tag",
-  cpu: 256,                    # CPU units
-  memory: 512,                 # Memory in MB
-  essential: true,             # Is this container essential?
-  port_mappings: [...],        # Port mappings
-  environment: [...],          # Environment variables
-  secrets: [...],              # Secrets from Parameter Store/Secrets Manager
-  health_check: {...},         # Container health check
-  depends_on: [...],           # Container dependencies
-  log_configuration: {...}     # Custom logging config (optional)
-}
-```
-
-## Outputs
-
-The component returns a `ComponentReference` with:
-
-- `service_name`: Name of the ECS service
-- `service_arn`: ARN of the ECS service
-- `task_definition_arn`: ARN of the task definition
-- `cluster_name`: Name of the ECS cluster
-- `service_discovery_endpoint`: Service discovery endpoint (if configured)
-- `resilience_features`: List of enabled resilience features
-- `monitoring_features`: List of enabled monitoring features
-- `estimated_monthly_cost`: Estimated AWS costs
-
-## Resources Created
-
-- `aws_cloudwatch_log_group`: CloudWatch log group for container logs
-- `aws_cloudwatch_log_stream`: Log streams for each container
-- `aws_ecs_task_definition`: Task definition with containers
-- `aws_ecs_service`: ECS service with deployment configuration
-- `aws_service_discovery_service`: Service discovery registration (optional)
-- `aws_appautoscaling_target`: Auto-scaling target (optional)
-- `aws_appautoscaling_policy`: CPU and memory scaling policies (optional)
-- `aws_cloudwatch_metric_alarm`: Monitoring alarms
-- `aws_xray_sampling_rule`: X-Ray sampling configuration (optional)
-
-## Best Practices
-
-1. **Container Configuration**
-   - Use specific image tags, not `latest`
-   - Set appropriate CPU and memory limits
-   - Define health checks for all containers
-   - Use secrets for sensitive configuration
-
-2. **Networking**
-   - Deploy across multiple availability zones
-   - Use private subnets for services
-   - Configure security groups with least privilege
-
-3. **Resilience**
-   - Enable circuit breakers for automatic rollback
-   - Configure appropriate health check grace periods
-   - Set deployment percentages for rolling updates
-   - Use auto-scaling for dynamic workloads
-
-4. **Observability**
-   - Enable distributed tracing for debugging
-   - Set appropriate log retention periods
-   - Configure CloudWatch alarms for key metrics
-   - Use structured logging in containers
-
-5. **Cost Optimization**
-   - Right-size CPU and memory allocations
-   - Use Fargate Spot for non-critical workloads
-   - Configure auto-scaling to match demand
-   - Review and adjust log retention policies