// Serverless vs. Container-Based Compute

// Serverless (AWS Lambda) - Auto-scaling, pay-per-use
const AWS = require('aws-sdk');
const lambda = new AWS.Lambda();

// Serverless function for lightweight processing
async function processEvent(event) {
  const response = await lambda.invoke({
    FunctionName: 'event-processor',
    Payload: JSON.stringify(event),
    InvocationType: 'RequestResponse' // Synchronous
  }).promise();

  return JSON.parse(response.Payload);
}

// Container (ECS/Kubernetes) - Consistent performance, GPU support
const ecs = new AWS.ECS();

async function runMLInferenceTask(imageData) {
  const response = await ecs.runTask({
    cluster: 'ml-inference-cluster',
    taskDefinition: 'ml-inference-task',
    launchType: 'FARGATE',
    networkConfiguration: {
      awsvpcConfiguration: {
        subnets: ['subnet-123'],
        assignPublicIp: 'ENABLED'
      }
    },
    overrides: {
      containerOverrides: [{
        name: 'ml-inference',
        environment: [{ name: 'IMAGE_DATA', value: imageData }]
      }]
    }
  }).promise();

  return response.tasks[0].taskArn;
}

// Hybrid: Serverless for orchestration, containers for heavy lifting
async function hybridPipeline(data) {
  // Step 1: Lightweight preprocessing (serverless)
  const preprocessed = await processEvent({ type: 'preprocess', data });

  // Step 2: Heavy computation (containers)
  const taskArn = await runMLInferenceTask(preprocessed);

  // Step 3: Lightweight postprocessing (serverless)
  const result = await processEvent({ type: 'postprocess', taskArn });
  return result;
}

// Cold start mitigation: Provisioned concurrency
async function provisionLambdaConcurrency() {
  await lambda.putProvisionedConcurrencyConfig({
    FunctionName: 'api-handler',
    ProvisionedConcurrentExecutions: 5, // Keep 5 warm instances
    Qualifier: 'production'
  }).promise();
}