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

runbooks/operate/ec2_operations.py

@@ -48,6 +48,9 @@ class EC2Operations(BaseOperation):
     supported_operations = {
         "start_instances",
         "stop_instances",
+        "list_unattached_elastic_ips",
+        "release_elastic_ip",
+        "get_elastic_ip_cost_impact",
         "terminate_instances",
         "run_instances",
         "copy_image",
@@ -59,6 +62,8 @@ class EC2Operations(BaseOperation):
         "analyze_rightsizing",
         "optimize_instance_types",
         "generate_cost_recommendations",
+        "get_ebs_volumes_with_low_usage",
+        "delete_volumes_by_id",
     }
     requires_confirmation = True
 
@@ -187,6 +192,14 @@ class EC2Operations(BaseOperation):
             return self.cleanup_unused_eips(context)
         elif operation_type == "reboot_instances":
             return self.reboot_instances(context, kwargs.get("instance_ids", []))
+        elif operation_type == "get_ebs_volumes_with_low_usage":
+            return self.get_ebs_volumes_with_low_usage(
+                context, 
+                kwargs.get("threshold_days", 10),
+                kwargs.get("usage_threshold", 10.0)
+            )
+        elif operation_type == "delete_volumes_by_id":
+            return self.delete_volumes_by_id(context, kwargs.get("volume_data", []))
         else:
             raise ValueError(f"Unsupported operation: {operation_type}")
 
@@ -200,11 +213,13 @@ class EC2Operations(BaseOperation):
 
             try:
                 if context.dry_run:
-                    console.print(Panel(
-                        f"[yellow]Would start instance {instance_id}[/yellow]",
-                        title="🏃 DRY-RUN MODE",
-                        border_style="yellow"
-                    ))
+                    console.print(
+                        Panel(
+                            f"[yellow]Would start instance {instance_id}[/yellow]",
+                            title="🏃 DRY-RUN MODE",
+                            border_style="yellow",
+                        )
+                    )
                     result.mark_completed(OperationStatus.DRY_RUN)
                 else:
                     response = self.execute_aws_call(ec2_client, "start_instances", InstanceIds=[instance_id])
@@ -682,6 +697,203 @@ class EC2Operations(BaseOperation):
 
         return [result]
 
+    def get_ebs_volumes_with_low_usage(
+        self, context: OperationContext, threshold_days: int = 10, usage_threshold: float = 10.0
+    ) -> List[OperationResult]:
+        """
+        Find EBS volumes with low usage based on CloudWatch VolumeUsage metric.
+        
+        Migrated from unSkript notebook: AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
+        Function: aws_get_ebs_volume_for_low_usage()
+        
+        Args:
+            context: Operation execution context
+            threshold_days: Number of days to analyze usage
+            usage_threshold: Usage percentage threshold (default: 10.0)
+            
+        Returns:
+            List of OperationResults with low usage volumes found
+        """
+        ec2_client = self.get_client("ec2", context.region)
+        cloudwatch_client = self.get_client("cloudwatch", context.region)
+        
+        result = self.create_operation_result(context, "get_ebs_volumes_with_low_usage", "ec2:volume", "analysis")
+        
+        try:
+            console.print(f"[blue]🔍 Analyzing EBS volume usage over {threshold_days} days...[/blue]")
+            
+            # Get all volumes - migrated logic from unSkript notebook
+            volumes_response = self.execute_aws_call(ec2_client, "describe_volumes")
+            low_usage_volumes = []
+            
+            now = datetime.utcnow()
+            days_ago = now - timedelta(days=threshold_days)
+            
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                transient=True,
+            ) as progress:
+                task = progress.add_task(f"Analyzing {len(volumes_response['Volumes'])} volumes...", total=len(volumes_response['Volumes']))
+                
+                for volume in volumes_response["Volumes"]:
+                    volume_id = volume["VolumeId"]
+                    
+                    try:
+                        # Get CloudWatch metrics for volume usage - exact logic from unSkript
+                        cloudwatch_response = cloudwatch_client.get_metric_statistics(
+                            Namespace='AWS/EBS',
+                            MetricName='VolumeUsage',
+                            Dimensions=[
+                                {
+                                    'Name': 'VolumeId',
+                                    'Value': volume_id
+                                }
+                            ],
+                            StartTime=days_ago,
+                            EndTime=now,
+                            Period=3600,
+                            Statistics=['Average']
+                        )
+                        
+                        # Analyze usage data - migrated from unSkript logic
+                        for datapoint in cloudwatch_response.get('Datapoints', []):
+                            if datapoint['Average'] < usage_threshold:
+                                ebs_volume = {
+                                    "volume_id": volume_id,
+                                    "region": context.region,
+                                    "size": volume["Size"],
+                                    "state": volume["State"],
+                                    "volume_type": volume.get("VolumeType", "unknown"),
+                                    "encrypted": volume.get("Encrypted", False),
+                                    "create_time": str(volume["CreateTime"]),
+                                    "average_usage": datapoint['Average'],
+                                    "timestamp": str(datapoint['Timestamp'])
+                                }
+                                low_usage_volumes.append(ebs_volume)
+                                logger.debug(f"Low usage volume found: {volume_id} (avg usage: {datapoint['Average']:.2f}%)")
+                                break
+                                
+                    except ClientError as e:
+                        # Handle individual volume metric errors gracefully
+                        logger.warning(f"Could not get metrics for volume {volume_id}: {e}")
+                        continue
+                    
+                    progress.update(task, advance=1)
+            
+            result.response_data = {
+                "low_usage_volumes": low_usage_volumes,
+                "count": len(low_usage_volumes),
+                "total_scanned": len(volumes_response["Volumes"]),
+                "threshold_days": threshold_days,
+                "usage_threshold": usage_threshold
+            }
+            result.mark_completed(OperationStatus.SUCCESS)
+            
+            if low_usage_volumes:
+                console.print(f"[yellow]⚠️  Found {len(low_usage_volumes)} volumes with usage < {usage_threshold}%[/yellow]")
+                
+                # Create Rich table for display
+                table = Table(title=f"Low Usage EBS Volumes (< {usage_threshold}%)")
+                table.add_column("Volume ID", style="cyan")
+                table.add_column("Size (GB)", justify="right")
+                table.add_column("Type", style="green")
+                table.add_column("Usage %", justify="right", style="red")
+                table.add_column("State")
+                
+                for vol in low_usage_volumes[:10]:  # Show first 10
+                    table.add_row(
+                        vol["volume_id"],
+                        str(vol["size"]),
+                        vol["volume_type"],
+                        f"{vol['average_usage']:.2f}%",
+                        vol["state"]
+                    )
+                    
+                console.print(table)
+                
+                if len(low_usage_volumes) > 10:
+                    console.print(f"[dim]... and {len(low_usage_volumes) - 10} more volumes[/dim]")
+                    
+                # SNS notification
+                message = f"Found {len(low_usage_volumes)} EBS volumes with usage < {usage_threshold}% in {context.region}"
+                self.send_sns_notification("Low Usage EBS Volumes Detected", message)
+            else:
+                console.print(f"[green]✅ No volumes found with usage < {usage_threshold}%[/green]")
+                
+        except Exception as e:
+            error_msg = f"Failed to analyze EBS volume usage: {e}"
+            logger.error(error_msg)
+            result.mark_completed(OperationStatus.FAILED, error_msg)
+            
+        return [result]
+    
+    def delete_volumes_by_id(self, context: OperationContext, volume_data: List[Dict[str, str]]) -> List[OperationResult]:
+        """
+        Delete EBS volumes by ID with safety checks and confirmation.
+        
+        Migrated from unSkript notebook: AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
+        Function: aws_delete_volume_by_id()
+        
+        Args:
+            context: Operation execution context
+            volume_data: List of dicts with 'volume_id' and 'region' keys
+            
+        Returns:
+            List of OperationResults for each volume deletion attempt
+        """
+        results = []
+        
+        for vol_data in volume_data:
+            volume_id = vol_data.get("volume_id")
+            region = vol_data.get("region", context.region)
+            
+            ec2_client = self.get_client("ec2", region)
+            result = self.create_operation_result(context, "delete_volumes_by_id", "ec2:volume", volume_id)
+            
+            try:
+                # Safety confirmation - enhanced from original
+                if not self.confirm_operation(context, volume_id, "delete EBS volume"):
+                    result.mark_completed(OperationStatus.CANCELLED, "Operation cancelled by user")
+                    results.append(result)
+                    continue
+                
+                if context.dry_run:
+                    console.print(f"[yellow]🏃 DRY-RUN: Would delete volume {volume_id} in {region}[/yellow]")
+                    result.mark_completed(OperationStatus.DRY_RUN)
+                else:
+                    # Execute deletion - exact logic from unSkript
+                    delete_response = self.execute_aws_call(ec2_client, "delete_volume", VolumeId=volume_id)
+                    
+                    result.response_data = delete_response
+                    result.mark_completed(OperationStatus.SUCCESS)
+                    console.print(f"[green]✅ Successfully deleted volume {volume_id}[/green]")
+                    logger.info(f"Deleted EBS volume: {volume_id} in {region}")
+                    
+            except ClientError as e:
+                error_msg = f"Failed to delete volume {volume_id}: {e}"
+                console.print(f"[red]❌ {error_msg}[/red]")
+                logger.error(error_msg)
+                result.mark_completed(OperationStatus.FAILED, error_msg)
+            except Exception as e:
+                error_msg = f"Unexpected error deleting volume {volume_id}: {e}"
+                console.print(f"[red]❌ {error_msg}[/red]")
+                logger.error(error_msg)
+                result.mark_completed(OperationStatus.FAILED, error_msg)
+                
+            results.append(result)
+        
+        # Summary reporting
+        successful_deletions = [r.resource_id for r in results if r.success]
+        if successful_deletions:
+            message = f"Successfully deleted {len(successful_deletions)} EBS volumes: {', '.join(successful_deletions[:5])}"
+            if len(successful_deletions) > 5:
+                message += f" and {len(successful_deletions) - 5} more"
+            self.send_sns_notification("EBS Volumes Deleted", message)
+            console.print(f"[green]🎯 Deletion Summary: {len(successful_deletions)}/{len(results)} volumes deleted successfully[/green]")
+        
+        return results
+
     def cleanup_unused_eips(self, context: OperationContext) -> List[OperationResult]:
         """
         Identify unused Elastic IPs with detailed reporting and SNS notifications.
@@ -1176,6 +1388,224 @@ def lambda_handler_run_instances(event, context):
 
 
 # CLI Support
+    def list_unattached_elastic_ips(self, context: OperationContext) -> List[OperationResult]:
+        """
+        Find all unattached Elastic IPs across regions.
+        
+        Extracted from: AWS_Release_Unattached_Elastic_IPs.ipynb
+        
+        Args:
+            context: Operation execution context
+            
+        Returns:
+            List of OperationResults with unattached Elastic IPs
+        """
+        console.print("[bold cyan]Scanning for unattached Elastic IPs...[/bold cyan]")
+        results = []
+        
+        # Get all regions to check
+        regions_to_check = [context.region] if context.region else self._get_all_regions()
+        
+        for region in regions_to_check:
+            result = OperationResult(
+                operation_id=f"list_unattached_eips_{region}",
+                operation_name="list_unattached_elastic_ips",
+                resource_id=f"region:{region}",
+                resource_type="elastic_ip",
+            )
+            
+            try:
+                # Create EC2 client for specific region
+                ec2_client = boto3.client('ec2', region_name=region)
+                
+                # Get all Elastic IPs in region
+                response = ec2_client.describe_addresses()
+                unattached_eips = []
+                
+                for eip in response.get('Addresses', []):
+                    # Check if EIP is not attached (no AssociationId)
+                    if 'AssociationId' not in eip:
+                        eip_info = {
+                            'public_ip': eip.get('PublicIp'),
+                            'allocation_id': eip.get('AllocationId'),
+                            'region': region,
+                            'domain': eip.get('Domain', 'vpc'),
+                            'network_interface_id': eip.get('NetworkInterfaceId'),
+                            'private_ip': eip.get('PrivateIpAddress'),
+                            'tags': eip.get('Tags', [])
+                        }
+                        unattached_eips.append(eip_info)
+                
+                if unattached_eips:
+                    result.add_output("unattached_eips", unattached_eips)
+                    result.add_output("count", len(unattached_eips))
+                    result.add_output("monthly_cost", len(unattached_eips) * 3.60)  # $3.60/month per EIP
+                    result.mark_completed(
+                        OperationStatus.SUCCESS,
+                        f"Found {len(unattached_eips)} unattached Elastic IPs in {region}"
+                    )
+                    console.print(f"[yellow]Found {len(unattached_eips)} unattached EIPs in {region}[/yellow]")
+                else:
+                    result.mark_completed(
+                        OperationStatus.SUCCESS,
+                        f"No unattached Elastic IPs found in {region}"
+                    )
+                    
+            except ClientError as e:
+                error_msg = f"Failed to list Elastic IPs in {region}: {e}"
+                logger.error(error_msg)
+                result.mark_completed(OperationStatus.FAILED, error_msg)
+                console.print(f"[red]Error scanning {region}: {e}[/red]")
+                
+            results.append(result)
+            
+        return results
+
+    def release_elastic_ip(self, context: OperationContext, allocation_id: str, region: str) -> OperationResult:
+        """
+        Release (delete) an unattached Elastic IP.
+        
+        Extracted from: AWS_Release_Unattached_Elastic_IPs.ipynb
+        
+        Args:
+            context: Operation execution context
+            allocation_id: Allocation ID of the Elastic IP
+            region: AWS region where the EIP exists
+            
+        Returns:
+            OperationResult with release status
+        """
+        result = OperationResult(
+            operation_id=f"release_eip_{allocation_id}",
+            operation_name="release_elastic_ip",
+            resource_id=allocation_id,
+            resource_type="elastic_ip",
+        )
+        
+        try:
+            ec2_client = boto3.client('ec2', region_name=region)
+            
+            if context.dry_run:
+                result.add_output("action", "DRY_RUN")
+                result.add_output("would_release", allocation_id)
+                result.add_output("monthly_savings", 3.60)
+                result.mark_completed(
+                    OperationStatus.SUCCESS,
+                    f"DRY RUN: Would release Elastic IP {allocation_id}"
+                )
+                console.print(f"[yellow]DRY RUN: Would release EIP {allocation_id}[/yellow]")
+            else:
+                # Actually release the Elastic IP
+                response = ec2_client.release_address(AllocationId=allocation_id)
+                result.add_output("response", response)
+                result.add_output("released", True)
+                result.add_output("monthly_savings", 3.60)
+                result.mark_completed(
+                    OperationStatus.SUCCESS,
+                    f"Successfully released Elastic IP {allocation_id}"
+                )
+                console.print(f"[green]✅ Released Elastic IP {allocation_id}[/green]")
+                
+        except ClientError as e:
+            error_msg = f"Failed to release Elastic IP {allocation_id}: {e}"
+            logger.error(error_msg)
+            result.mark_completed(OperationStatus.FAILED, error_msg)
+            console.print(f"[red]❌ Failed to release {allocation_id}: {e}[/red]")
+            
+        return result
+
+    def get_elastic_ip_cost_impact(self, context: OperationContext) -> OperationResult:
+        """
+        Calculate cost impact of unattached Elastic IPs.
+        
+        Args:
+            context: Operation execution context
+            
+        Returns:
+            OperationResult with cost analysis
+        """
+        result = OperationResult(
+            operation_id=f"eip_cost_analysis_{context.account_id}",
+            operation_name="get_elastic_ip_cost_impact",
+            resource_id=f"account:{context.account_id}",
+            resource_type="cost_analysis",
+        )
+        
+        try:
+            # Get all unattached EIPs
+            eip_results = self.list_unattached_elastic_ips(context)
+            
+            total_unattached = 0
+            total_monthly_cost = 0.0
+            regions_with_waste = []
+            
+            for eip_result in eip_results:
+                if eip_result.status == OperationStatus.SUCCESS and eip_result.outputs:
+                    count = eip_result.outputs.get('count', 0)
+                    if count > 0:
+                        total_unattached += count
+                        monthly_cost = eip_result.outputs.get('monthly_cost', 0)
+                        total_monthly_cost += monthly_cost
+                        regions_with_waste.append({
+                            'region': eip_result.resource_id.split(':')[1],
+                            'count': count,
+                            'monthly_cost': monthly_cost
+                        })
+            
+            # Create cost analysis summary
+            cost_summary = {
+                'total_unattached_eips': total_unattached,
+                'total_monthly_cost': total_monthly_cost,
+                'total_annual_cost': total_monthly_cost * 12,
+                'regions_affected': len(regions_with_waste),
+                'regions_detail': regions_with_waste,
+                'cost_per_eip_monthly': 3.60,
+                'recommendation': 'Release unattached Elastic IPs to save costs'
+            }
+            
+            result.add_output("cost_analysis", cost_summary)
+            result.mark_completed(
+                OperationStatus.SUCCESS,
+                f"Cost analysis complete: ${total_monthly_cost:.2f}/month waste from {total_unattached} unattached EIPs"
+            )
+            
+            # Display cost impact table
+            if total_unattached > 0:
+                table = Table(title="Elastic IP Cost Impact Analysis")
+                table.add_column("Metric", style="cyan")
+                table.add_column("Value", style="yellow")
+                
+                table.add_row("Unattached EIPs", str(total_unattached))
+                table.add_row("Monthly Cost", f"${total_monthly_cost:.2f}")
+                table.add_row("Annual Cost", f"${total_monthly_cost * 12:.2f}")
+                table.add_row("Regions Affected", str(len(regions_with_waste)))
+                
+                console.print(table)
+                console.print(f"[bold red]💰 Potential savings: ${total_monthly_cost:.2f}/month[/bold red]")
+            else:
+                console.print("[green]✅ No unattached Elastic IPs found - no waste![/green]")
+                
+        except Exception as e:
+            error_msg = f"Failed to analyze Elastic IP costs: {e}"
+            logger.error(error_msg)
+            result.mark_completed(OperationStatus.FAILED, error_msg)
+            
+        return result
+
+    def _get_all_regions(self) -> List[str]:
+        """Get all available AWS regions for EC2."""
+        try:
+            ec2_client = boto3.client('ec2', region_name='us-east-1')
+            response = ec2_client.describe_regions()
+            return [region['RegionName'] for region in response['Regions']]
+        except Exception:
+            # Fallback to common regions if API call fails
+            return [
+                'us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1',
+                'us-west-1', 'eu-central-1', 'ap-southeast-2'
+            ]
+
+
 def main():
     """Main entry point for standalone execution."""
     import sys