// Spot vs. On-Demand: Handling spot instance interruptions

import boto3
import signal
import sys

class SpotInstanceManager:
    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.setup_interrupt_handler()
    
    def setup_interrupt_handler(self):
        """Handle spot termination notices"""
        signal.signal(signal.SIGTERM, self.handle_interrupt)
    
    def handle_interrupt(self, signum, frame):
        """Gracefully shutdown and save state"""
        print("Spot interruption detected, saving checkpoint...")
        self.save_checkpoint()
        self.graceful_shutdown()
    
    def request_spot_instances(self, instance_type, count, bid_price):
        """Request spot instances with fallback to on-demand"""
        try:
            response = self.ec2.request_spot_instances(
                SpotPrice=str(bid_price),
                InstanceCount=count,
                LaunchSpecification={
                    'ImageId': 'ami-12345',
                    'InstanceType': instance_type,
                }
            )
            return response
        except self.ec2.exceptions.ClientError as e:
            print(f"Spot unavailable, falling back to on-demand: {e}")
            return self.request_on_demand_instances(instance_type, count)
    
    def request_on_demand_instances(self, instance_type, count):
        """Fallback to on-demand instances"""
        response = self.ec2.run_instances(
            ImageId='ami-12345',
            InstanceType=instance_type,
            MinCount=count,
            MaxCount=count
        )
        return response

// AWS Fargate Spot: Managed spot for containers
const ecs = new AWS.ECS();

const taskDefinition = {
    family: 'batch-processor',
    requiresCompatibilities: ['FARGATE'],
    cpu: '256',
    memory: '512',
    networkMode: 'awsvpc'
};

const runTask = async () => {
    try {
        await ecs.runTask({
            cluster: 'batch-cluster',
            taskDefinition: 'batch-processor',
            launchType: 'FARGATE',
            capacityProviderStrategy: [{
                capacityProvider: 'FARGATE_SPOT',  // Try spot first
                weight: 1
            }, {
                capacityProvider: 'FARGATE',        // Fallback to Fargate
                weight: 1,
                base: 1  // Always maintain some on-demand capacity
            }]
        });
    } catch (error) {
        console.error('Task failed:', error);
    }
};