runbooks 0.7.6__py3-none-any.whl → 0.7.9__py3-none-any.whl

runbooks/vpc/__init__.py

@@ -0,0 +1,38 @@
+"""
+VPC Networking Operations Module
+
+This module provides comprehensive VPC networking analysis and optimization capabilities
+with support for both CLI and Jupyter notebook interfaces using Rich for beautiful outputs.
+
+Key Components:
+- VPCNetworkingWrapper: Main interface for all VPC operations
+- VPCManagerInterface: Business-friendly interface for non-technical users
+- NetworkingCostEngine: Cost analysis and optimization engine
+- NetworkingCostHeatMapEngine: Heat map generation for cost visualization
+- Rich formatters: Consistent, beautiful output formatting
+
+Usage:
+    CLI: runbooks vpc analyze --profile aws-profile
+    Jupyter: from runbooks.vpc import VPCNetworkingWrapper
+    Manager Dashboard: from runbooks.vpc import VPCManagerInterface
+"""
+
+from .cost_engine import NetworkingCostEngine
+from .heatmap_engine import NetworkingCostHeatMapEngine
+from .networking_wrapper import VPCNetworkingWrapper
+from .manager_interface import VPCManagerInterface, BusinessRecommendation, ManagerDashboardConfig
+from .rich_formatters import display_cost_table, display_heatmap, display_optimization_recommendations
+
+__all__ = [
+    "VPCNetworkingWrapper",
+    "VPCManagerInterface",
+    "BusinessRecommendation", 
+    "ManagerDashboardConfig",
+    "NetworkingCostEngine",
+    "NetworkingCostHeatMapEngine",
+    "display_cost_table",
+    "display_heatmap",
+    "display_optimization_recommendations",
+]
+
+__version__ = "1.0.0"

runbooks/vpc/config.py

@@ -0,0 +1,212 @@
+"""
+VPC Networking Configuration Management
+
+This module provides configurable parameters for VPC networking operations,
+replacing hard-coded values with environment-aware configuration.
+"""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class AWSCostModel:
+    """AWS Service Cost Model with configurable pricing"""
+
+    # NAT Gateway Pricing (configurable via environment)
+    nat_gateway_hourly: float = field(default_factory=lambda: float(os.getenv("AWS_NAT_GATEWAY_HOURLY", "0.045")))
+    nat_gateway_monthly: float = field(default_factory=lambda: float(os.getenv("AWS_NAT_GATEWAY_MONTHLY", "45.0")))
+    nat_gateway_data_processing: float = field(
+        default_factory=lambda: float(os.getenv("AWS_NAT_GATEWAY_DATA_PROCESSING", "0.045"))
+    )
+
+    # Transit Gateway Pricing
+    transit_gateway_hourly: float = field(
+        default_factory=lambda: float(os.getenv("AWS_TRANSIT_GATEWAY_HOURLY", "0.05"))
+    )
+    transit_gateway_monthly: float = field(
+        default_factory=lambda: float(os.getenv("AWS_TRANSIT_GATEWAY_MONTHLY", "36.50"))
+    )
+    transit_gateway_attachment: float = field(
+        default_factory=lambda: float(os.getenv("AWS_TRANSIT_GATEWAY_ATTACHMENT", "0.05"))
+    )
+    transit_gateway_data_processing: float = field(
+        default_factory=lambda: float(os.getenv("AWS_TRANSIT_GATEWAY_DATA_PROCESSING", "0.02"))
+    )
+
+    # VPC Endpoint Pricing
+    vpc_endpoint_interface_hourly: float = field(
+        default_factory=lambda: float(os.getenv("AWS_VPC_ENDPOINT_INTERFACE_HOURLY", "0.01"))
+    )
+    vpc_endpoint_interface_monthly: float = field(
+        default_factory=lambda: float(os.getenv("AWS_VPC_ENDPOINT_INTERFACE_MONTHLY", "10.0"))
+    )
+    vpc_endpoint_gateway: float = 0.0  # Always free
+    vpc_endpoint_data_processing: float = field(
+        default_factory=lambda: float(os.getenv("AWS_VPC_ENDPOINT_DATA_PROCESSING", "0.01"))
+    )
+
+    # Elastic IP Pricing
+    elastic_ip_idle_hourly: float = field(
+        default_factory=lambda: float(os.getenv("AWS_ELASTIC_IP_IDLE_HOURLY", "0.005"))
+    )
+    elastic_ip_idle_monthly: float = field(
+        default_factory=lambda: float(os.getenv("AWS_ELASTIC_IP_IDLE_MONTHLY", "3.60"))
+    )
+    elastic_ip_attached: float = 0.0  # Always free when attached
+    elastic_ip_remap: float = field(default_factory=lambda: float(os.getenv("AWS_ELASTIC_IP_REMAP", "0.10")))
+
+    # Data Transfer Pricing
+    data_transfer_inter_az: float = field(
+        default_factory=lambda: float(os.getenv("AWS_DATA_TRANSFER_INTER_AZ", "0.01"))
+    )
+    data_transfer_inter_region: float = field(
+        default_factory=lambda: float(os.getenv("AWS_DATA_TRANSFER_INTER_REGION", "0.02"))
+    )
+    data_transfer_internet_out: float = field(
+        default_factory=lambda: float(os.getenv("AWS_DATA_TRANSFER_INTERNET_OUT", "0.09"))
+    )
+    data_transfer_s3_same_region: float = 0.0  # Always free
+
+
+@dataclass
+class OptimizationThresholds:
+    """Configurable thresholds for optimization recommendations"""
+
+    # Usage thresholds
+    idle_connection_threshold: int = field(default_factory=lambda: int(os.getenv("IDLE_CONNECTION_THRESHOLD", "10")))
+    low_usage_gb_threshold: float = field(default_factory=lambda: float(os.getenv("LOW_USAGE_GB_THRESHOLD", "100.0")))
+    low_connection_threshold: int = field(default_factory=lambda: int(os.getenv("LOW_CONNECTION_THRESHOLD", "100")))
+
+    # Cost thresholds
+    high_cost_threshold: float = field(default_factory=lambda: float(os.getenv("HIGH_COST_THRESHOLD", "100.0")))
+    critical_cost_threshold: float = field(default_factory=lambda: float(os.getenv("CRITICAL_COST_THRESHOLD", "500.0")))
+
+    # Optimization targets
+    target_reduction_percent: float = field(
+        default_factory=lambda: float(os.getenv("TARGET_REDUCTION_PERCENT", "30.0"))
+    )
+
+    # Enterprise approval thresholds (from user requirements)
+    cost_approval_threshold: float = field(
+        default_factory=lambda: float(os.getenv("COST_APPROVAL_THRESHOLD", "1000.0"))
+    )  # $1000/month
+    performance_baseline_threshold: float = field(
+        default_factory=lambda: float(os.getenv("PERFORMANCE_BASELINE_THRESHOLD", "2.0"))
+    )  # 2 seconds
+
+
+@dataclass
+class RegionalConfiguration:
+    """Regional cost multipliers and configuration"""
+
+    # Default regions for analysis
+    default_regions: List[str] = field(
+        default_factory=lambda: [
+            "us-east-1",
+            "us-west-2",
+            "us-west-1",
+            "eu-west-1",
+            "eu-central-1",
+            "eu-west-2",
+            "ap-southeast-1",
+            "ap-southeast-2",
+            "ap-northeast-1",
+        ]
+    )
+
+    # Regional cost multipliers (can be overridden by data from AWS Pricing API)
+    regional_multipliers: Dict[str, float] = field(
+        default_factory=lambda: {
+            "us-east-1": float(os.getenv("COST_MULTIPLIER_US_EAST_1", "1.5")),
+            "us-west-2": float(os.getenv("COST_MULTIPLIER_US_WEST_2", "1.3")),
+            "us-west-1": float(os.getenv("COST_MULTIPLIER_US_WEST_1", "0.8")),
+            "eu-west-1": float(os.getenv("COST_MULTIPLIER_EU_WEST_1", "1.2")),
+            "eu-central-1": float(os.getenv("COST_MULTIPLIER_EU_CENTRAL_1", "0.9")),
+            "eu-west-2": float(os.getenv("COST_MULTIPLIER_EU_WEST_2", "0.7")),
+            "ap-southeast-1": float(os.getenv("COST_MULTIPLIER_AP_SOUTHEAST_1", "1.0")),
+            "ap-southeast-2": float(os.getenv("COST_MULTIPLIER_AP_SOUTHEAST_2", "0.8")),
+            "ap-northeast-1": float(os.getenv("COST_MULTIPLIER_AP_NORTHEAST_1", "1.1")),
+        }
+    )
+
+
+@dataclass
+class VPCNetworkingConfig:
+    """Main VPC Networking Configuration"""
+
+    # AWS Configuration
+    default_region: str = field(default_factory=lambda: os.getenv("AWS_DEFAULT_REGION", "us-east-1"))
+
+    # AWS Profiles
+    billing_profile: Optional[str] = field(default_factory=lambda: os.getenv("BILLING_PROFILE"))
+    centralized_ops_profile: Optional[str] = field(default_factory=lambda: os.getenv("CENTRALIZED_OPS_PROFILE"))
+    single_account_profile: Optional[str] = field(default_factory=lambda: os.getenv("SINGLE_ACCOUNT_PROFILE"))
+    management_profile: Optional[str] = field(default_factory=lambda: os.getenv("MANAGEMENT_PROFILE"))
+
+    # Analysis Configuration
+    default_analysis_days: int = field(default_factory=lambda: int(os.getenv("DEFAULT_ANALYSIS_DAYS", "30")))
+    forecast_days: int = field(default_factory=lambda: int(os.getenv("FORECAST_DAYS", "90")))
+
+    # Output Configuration
+    default_output_format: str = field(default_factory=lambda: os.getenv("OUTPUT_FORMAT", "rich"))
+    default_output_dir: Path = field(default_factory=lambda: Path(os.getenv("OUTPUT_DIR", "./exports")))
+
+    # Enterprise Configuration
+    enable_cost_approval_workflow: bool = field(
+        default_factory=lambda: os.getenv("ENABLE_COST_APPROVAL_WORKFLOW", "true").lower() == "true"
+    )
+    enable_mcp_validation: bool = field(
+        default_factory=lambda: os.getenv("ENABLE_MCP_VALIDATION", "false").lower() == "true"
+    )
+
+    # Component configurations
+    cost_model: AWSCostModel = field(default_factory=AWSCostModel)
+    thresholds: OptimizationThresholds = field(default_factory=OptimizationThresholds)
+    regional: RegionalConfiguration = field(default_factory=RegionalConfiguration)
+
+    def get_cost_approval_required(self, monthly_cost: float) -> bool:
+        """Check if cost requires approval based on threshold"""
+        return self.enable_cost_approval_workflow and monthly_cost > self.thresholds.cost_approval_threshold
+
+    def get_performance_acceptable(self, execution_time: float) -> bool:
+        """Check if performance meets baseline requirements"""
+        return execution_time <= self.thresholds.performance_baseline_threshold
+
+    def get_regional_multiplier(self, region: str) -> float:
+        """Get cost multiplier for specific region"""
+        return self.regional.regional_multipliers.get(region, 1.0)
+
+
+def load_config(config_file: Optional[str] = None) -> VPCNetworkingConfig:
+    """
+    Load VPC networking configuration from environment and optional config file
+
+    Args:
+        config_file: Optional path to configuration file
+
+    Returns:
+        VPCNetworkingConfig instance
+    """
+    # TODO: Add support for loading from JSON/YAML config file
+    # TODO: Add support for AWS Pricing API integration
+
+    config = VPCNetworkingConfig()
+
+    # Validate configuration only in production (not during testing)
+    is_testing = os.getenv("PYTEST_CURRENT_TEST") is not None or "pytest" in os.environ.get("_", "")
+    if not is_testing and config.enable_cost_approval_workflow and not config.billing_profile:
+        raise ValueError("BILLING_PROFILE required when cost approval workflow is enabled")
+
+    return config
+
+
+# Global configuration instance (with testing environment detection)
+default_config = None
+try:
+    default_config = load_config()
+except ValueError:
+    # Fallback configuration for testing or when validation fails
+    default_config = VPCNetworkingConfig(enable_cost_approval_workflow=False)

runbooks/vpc/cost_engine.py

@@ -0,0 +1,347 @@
+"""
+Networking Cost Engine - Core cost analysis and calculation logic
+"""
+
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Tuple
+
+import boto3
+import numpy as np
+from botocore.exceptions import ClientError
+
+from .config import VPCNetworkingConfig, load_config
+
+logger = logging.getLogger(__name__)
+
+
+class NetworkingCostEngine:
+    """
+    Core engine for networking cost calculations and analysis
+    """
+
+    def __init__(self, session: Optional[boto3.Session] = None, config: Optional[VPCNetworkingConfig] = None):
+        """
+        Initialize the cost engine
+
+        Args:
+            session: Boto3 session for AWS API calls
+            config: VPC networking configuration (uses default if None)
+        """
+        self.session = session or boto3.Session()
+        self.config = config or load_config()
+        self.cost_model = self.config.cost_model
+        self._cost_explorer_client = None
+        self._cloudwatch_client = None
+
+    @property
+    def cost_explorer(self):
+        """Lazy load Cost Explorer client"""
+        if not self._cost_explorer_client:
+            self._cost_explorer_client = self.session.client("ce", region_name="us-east-1")
+        return self._cost_explorer_client
+
+    @property
+    def cloudwatch(self):
+        """Lazy load CloudWatch client"""
+        if not self._cloudwatch_client:
+            self._cloudwatch_client = self.session.client("cloudwatch")
+        return self._cloudwatch_client
+
+    def calculate_nat_gateway_cost(
+        self, nat_gateway_id: str, days: int = 30, include_data_processing: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Calculate NAT Gateway costs
+
+        Args:
+            nat_gateway_id: NAT Gateway ID
+            days: Number of days to analyze
+            include_data_processing: Include data processing charges
+
+        Returns:
+            Dictionary with cost breakdown
+        """
+        cost_breakdown = {
+            "nat_gateway_id": nat_gateway_id,
+            "period_days": days,
+            "base_cost": 0.0,
+            "data_processing_cost": 0.0,
+            "total_cost": 0.0,
+            "daily_average": 0.0,
+            "monthly_projection": 0.0,
+        }
+
+        # Base cost calculation
+        cost_breakdown["base_cost"] = self.cost_model.nat_gateway_hourly * 24 * days
+
+        if include_data_processing:
+            try:
+                # Get data processing metrics from CloudWatch
+                end_time = datetime.now()
+                start_time = end_time - timedelta(days=days)
+
+                response = self.cloudwatch.get_metric_statistics(
+                    Namespace="AWS/NATGateway",
+                    MetricName="BytesOutToDestination",
+                    Dimensions=[{"Name": "NatGatewayId", "Value": nat_gateway_id}],
+                    StartTime=start_time,
+                    EndTime=end_time,
+                    Period=86400 * days,
+                    Statistics=["Sum"],
+                )
+
+                if response["Datapoints"]:
+                    total_bytes = sum([p["Sum"] for p in response["Datapoints"]])
+                    total_gb = total_bytes / (1024**3)
+                    cost_breakdown["data_processing_cost"] = total_gb * self.cost_model.nat_gateway_data_processing
+            except Exception as e:
+                logger.warning(f"Failed to get data processing metrics: {e}")
+
+        # Calculate totals
+        cost_breakdown["total_cost"] = cost_breakdown["base_cost"] + cost_breakdown["data_processing_cost"]
+        cost_breakdown["daily_average"] = cost_breakdown["total_cost"] / days
+        cost_breakdown["monthly_projection"] = cost_breakdown["daily_average"] * 30
+
+        return cost_breakdown
+
+    def calculate_vpc_endpoint_cost(
+        self, endpoint_type: str, availability_zones: int = 1, data_processed_gb: float = 0
+    ) -> Dict[str, Any]:
+        """
+        Calculate VPC Endpoint costs
+
+        Args:
+            endpoint_type: 'Interface' or 'Gateway'
+            availability_zones: Number of AZs for interface endpoints
+            data_processed_gb: Data processed in GB
+
+        Returns:
+            Dictionary with cost breakdown
+        """
+        cost_breakdown = {
+            "endpoint_type": endpoint_type,
+            "availability_zones": availability_zones,
+            "data_processed_gb": data_processed_gb,
+            "base_cost": 0.0,
+            "data_processing_cost": 0.0,
+            "total_monthly_cost": 0.0,
+        }
+
+        if endpoint_type == "Interface":
+            # Interface endpoints cost per AZ
+            cost_breakdown["base_cost"] = self.cost_model.vpc_endpoint_interface_monthly * availability_zones
+            cost_breakdown["data_processing_cost"] = data_processed_gb * self.cost_model.vpc_endpoint_data_processing
+        else:
+            # Gateway endpoints are free
+            cost_breakdown["base_cost"] = 0.0
+            cost_breakdown["data_processing_cost"] = 0.0
+
+        cost_breakdown["total_monthly_cost"] = cost_breakdown["base_cost"] + cost_breakdown["data_processing_cost"]
+
+        return cost_breakdown
+
+    def calculate_transit_gateway_cost(
+        self, attachments: int, data_processed_gb: float = 0, days: int = 30
+    ) -> Dict[str, Any]:
+        """
+        Calculate Transit Gateway costs
+
+        Args:
+            attachments: Number of attachments
+            data_processed_gb: Data processed in GB
+            days: Number of days
+
+        Returns:
+            Dictionary with cost breakdown
+        """
+        cost_breakdown = {
+            "attachments": attachments,
+            "data_processed_gb": data_processed_gb,
+            "base_cost": 0.0,
+            "attachment_cost": 0.0,
+            "data_processing_cost": 0.0,
+            "total_cost": 0.0,
+            "monthly_projection": 0.0,
+        }
+
+        # Base Transit Gateway cost
+        cost_breakdown["base_cost"] = self.cost_model.transit_gateway_hourly * 24 * days
+
+        # Attachment costs
+        cost_breakdown["attachment_cost"] = self.cost_model.transit_gateway_attachment * 24 * days * attachments
+
+        # Data processing costs
+        cost_breakdown["data_processing_cost"] = data_processed_gb * self.cost_model.transit_gateway_data_processing
+
+        # Calculate totals
+        cost_breakdown["total_cost"] = (
+            cost_breakdown["base_cost"] + cost_breakdown["attachment_cost"] + cost_breakdown["data_processing_cost"]
+        )
+
+        cost_breakdown["monthly_projection"] = cost_breakdown["total_cost"] / days * 30
+
+        return cost_breakdown
+
+    def calculate_elastic_ip_cost(self, idle_hours: int = 0, remaps: int = 0) -> Dict[str, Any]:
+        """
+        Calculate Elastic IP costs
+
+        Args:
+            idle_hours: Hours the EIP was idle
+            remaps: Number of remaps
+
+        Returns:
+            Dictionary with cost breakdown
+        """
+        cost_breakdown = {
+            "idle_hours": idle_hours,
+            "remaps": remaps,
+            "idle_cost": idle_hours * self.cost_model.elastic_ip_idle_hourly,
+            "remap_cost": remaps * self.cost_model.elastic_ip_remap,
+            "total_cost": 0.0,
+            "monthly_projection": 0.0,
+        }
+
+        cost_breakdown["total_cost"] = cost_breakdown["idle_cost"] + cost_breakdown["remap_cost"]
+
+        # Project to monthly (assuming same pattern)
+        if idle_hours > 0:
+            days_analyzed = idle_hours / 24
+            cost_breakdown["monthly_projection"] = cost_breakdown["total_cost"] / days_analyzed * 30
+        else:
+            cost_breakdown["monthly_projection"] = cost_breakdown["total_cost"]
+
+        return cost_breakdown
+
+    def calculate_data_transfer_cost(
+        self, inter_az_gb: float = 0, inter_region_gb: float = 0, internet_out_gb: float = 0
+    ) -> Dict[str, Any]:
+        """
+        Calculate data transfer costs
+
+        Args:
+            inter_az_gb: Inter-AZ transfer in GB
+            inter_region_gb: Inter-region transfer in GB
+            internet_out_gb: Internet outbound transfer in GB
+
+        Returns:
+            Dictionary with cost breakdown
+        """
+        cost_breakdown = {
+            "inter_az_gb": inter_az_gb,
+            "inter_region_gb": inter_region_gb,
+            "internet_out_gb": internet_out_gb,
+            "inter_az_cost": inter_az_gb * self.cost_model.data_transfer_inter_az,
+            "inter_region_cost": inter_region_gb * self.cost_model.data_transfer_inter_region,
+            "internet_out_cost": internet_out_gb * self.cost_model.data_transfer_internet_out,
+            "total_cost": 0.0,
+        }
+
+        cost_breakdown["total_cost"] = (
+            cost_breakdown["inter_az_cost"] + cost_breakdown["inter_region_cost"] + cost_breakdown["internet_out_cost"]
+        )
+
+        return cost_breakdown
+
+    def get_actual_costs_from_cost_explorer(
+        self, service: str, start_date: str, end_date: str, granularity: str = "MONTHLY"
+    ) -> Dict[str, Any]:
+        """
+        Get actual costs from AWS Cost Explorer
+
+        Args:
+            service: AWS service name
+            start_date: Start date (YYYY-MM-DD)
+            end_date: End date (YYYY-MM-DD)
+            granularity: DAILY, MONTHLY, or HOURLY
+
+        Returns:
+            Dictionary with actual cost data
+        """
+        try:
+            response = self.cost_explorer.get_cost_and_usage(
+                TimePeriod={"Start": start_date, "End": end_date},
+                Granularity=granularity,
+                Metrics=["BlendedCost", "UnblendedCost"],
+                Filter={"Dimensions": {"Key": "SERVICE", "Values": [service]}},
+            )
+
+            cost_data = {
+                "service": service,
+                "period": f"{start_date} to {end_date}",
+                "granularity": granularity,
+                "total_cost": 0.0,
+                "results_by_time": [],
+            }
+
+            for result in response["ResultsByTime"]:
+                period_cost = float(result["Total"]["BlendedCost"]["Amount"])
+                cost_data["total_cost"] += period_cost
+                cost_data["results_by_time"].append(
+                    {
+                        "start": result["TimePeriod"]["Start"],
+                        "end": result["TimePeriod"]["End"],
+                        "cost": period_cost,
+                        "unit": result["Total"]["BlendedCost"]["Unit"],
+                    }
+                )
+
+            return cost_data
+
+        except Exception as e:
+            logger.error(f"Failed to get costs from Cost Explorer: {e}")
+            return {"service": service, "error": str(e), "total_cost": 0.0}
+
+    def estimate_optimization_savings(
+        self, current_costs: Dict[str, float], optimization_scenarios: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Estimate savings from optimization scenarios
+
+        Args:
+            current_costs: Current cost breakdown by service
+            optimization_scenarios: List of optimization scenarios
+
+        Returns:
+            Dictionary with savings estimates
+        """
+        total_current = sum(current_costs.values())
+
+        savings_analysis = {
+            "current_monthly_cost": total_current,
+            "scenarios": [],
+            "recommended_scenario": None,
+            "maximum_savings": 0.0,
+        }
+
+        for scenario in optimization_scenarios:
+            scenario_savings = 0.0
+            optimized_costs = current_costs.copy()
+
+            # Apply optimization percentages
+            for service, reduction_pct in scenario.get("reductions", {}).items():
+                if service in optimized_costs:
+                    savings = optimized_costs[service] * (reduction_pct / 100)
+                    scenario_savings += savings
+                    optimized_costs[service] -= savings
+
+            scenario_result = {
+                "name": scenario.get("name", "Unnamed"),
+                "description": scenario.get("description", ""),
+                "monthly_savings": scenario_savings,
+                "annual_savings": scenario_savings * 12,
+                "new_monthly_cost": total_current - scenario_savings,
+                "savings_percentage": (scenario_savings / total_current) * 100 if total_current > 0 else 0,
+                "risk_level": scenario.get("risk_level", "medium"),
+                "implementation_effort": scenario.get("effort", "medium"),
+            }
+
+            savings_analysis["scenarios"].append(scenario_result)
+
+            if scenario_savings > savings_analysis["maximum_savings"]:
+                savings_analysis["maximum_savings"] = scenario_savings
+                savings_analysis["recommended_scenario"] = scenario_result
+
+        return savings_analysis