import json
import urllib.parse
import boto3

s3 = boto3.client('s3')

def lambda_handler(event, context):
    # Obtener el bucket y objeto clave del evento
    bucket = event['Records'][0]['s3']['bucket']['name']
    key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'])
    
    try:
        # Obtener metadata del objeto
        response = s3.head_object(Bucket=bucket, Key=key)
        object_size = response['ContentLength']
        content_type = response['ContentType']
        
        # Procesar según el tipo de contenido
        if content_type.startswith('image/'):
            # Lógica para procesar imágenes
            process_image(bucket, key)
        elif content_type.startswith('application/pdf'):
            # Lógica para procesar PDFs
            process_pdf(bucket, key)
            
        return {
            'statusCode': 200,
            'body': json.dumps({
                'message': f'Procesado exitoso de {key} ({object_size} bytes)',
                'content_type': content_type
            })
        }
    except Exception as e:
        print(e)
        return {
            'statusCode': 500,
            'body': json.dumps({
                'message': f'Error al procesar {key}: {str(e)}'
            })
        }

def process_image(bucket, key):
    # Implementación del procesamiento de imágenes
    print(f"Procesando imagen: {bucket}/{key}")
    
def process_pdf(bucket, key):
    # Implementación del procesamiento de PDFs
    print(f"Procesando PDF: {bucket}/{key}")

// Lambda para búsqueda de productos
const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();

exports.handler = async (event) => {
    const searchTerm = event.queryStringParameters?.query || '';
    const category = event.queryStringParameters?.category || '';
    
    // Construir expresiones de filtro dinámicas
    let filterExpression = 'contains(#name, :searchTerm)';
    let expressionAttributeNames = { '#name': 'productName' };
    let expressionAttributeValues = { ':searchTerm': searchTerm };
    
    if (category) {
        filterExpression += ' AND #category = :category';
        expressionAttributeNames['#category'] = 'category';
        expressionAttributeValues[':category'] = category;
    }
    
    const params = {
        TableName: 'Products',
        FilterExpression: filterExpression,
        ExpressionAttributeNames: expressionAttributeNames,
        ExpressionAttributeValues: expressionAttributeValues
    };
    
    try {
        const result = await dynamodb.scan(params).promise();
        
        return {
            statusCode: 200,
            headers: {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'
            },
            body: JSON.stringify({
                products: result.Items,
                count: result.Count,
                searchTerm,
                category
            })
        };
    } catch (error) {
        console.error('Error al buscar productos:', error);
        
        return {
            statusCode: 500,
            body: JSON.stringify({
                message: 'Error interno al buscar productos',
                error: error.message
            })
        };
    }
};

import boto3
import datetime
import os

ec2 = boto3.client('ec2')
retention_days = int(os.environ.get('RETENTION_DAYS', 7))

def lambda_handler(event, context):
    # Obtener todos los volúmenes con la etiqueta AutoBackup=true
    volumes = ec2.describe_volumes(
        Filters=[
            {'Name': 'tag:AutoBackup', 'Values': ['true']}
        ]
    )
    
    snapshot_count = 0
    for volume in volumes['Volumes']:
        volume_id = volume['VolumeId']
        
        # Crear descripción para el snapshot
        description = f"AutoBackup de {volume_id} creado {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
        
        # Obtener el nombre de la instancia para la etiqueta
        instance_name = "Unattached"
        if len(volume['Attachments']) > 0:
            instance_id = volume['Attachments'][0]['InstanceId']
            instance = ec2.describe_instances(InstanceIds=[instance_id])
            for tag in instance['Reservations'][0]['Instances'][0].get('Tags', []):
                if tag['Key'] == 'Name':
                    instance_name = tag['Value']
        
        # Crear snapshot
        snapshot = ec2.create_snapshot(
            VolumeId=volume_id,
            Description=description,
            TagSpecifications=[
                {
                    'ResourceType': 'snapshot',
                    'Tags': [
                        {'Key': 'Name', 'Value': f"AutoBackup-{volume_id}"},
                        {'Key': 'AutoBackup', 'Value': 'true'},
                        {'Key': 'Instance', 'Value': instance_name},
                        {'Key': 'CreatedBy', 'Value': 'LambdaAutoBackup'}
                    ]
                }
            ]
        )
        
        snapshot_count += 1
        
    # Limpiar snapshots antiguos
    cleanup_count = cleanup_old_snapshots(retention_days)
    
    return {
        'statusCode': 200,
        'body': f"Creados {snapshot_count} snapshots. Eliminados {cleanup_count} snapshots antiguos."
    }

def cleanup_old_snapshots(days):
    # Calcular la fecha de corte
    cutoff_date = datetime.datetime.now() - datetime.timedelta(days=days)
    
    # Obtener snapshots con la etiqueta AutoBackup=true
    snapshots = ec2.describe_snapshots(
        Filters=[
            {'Name': 'tag:AutoBackup', 'Values': ['true']},
            {'Name': 'tag:CreatedBy', 'Values': ['LambdaAutoBackup']}
        ],
        OwnerIds=['self']
    )
    
    deleted_count = 0
    for snapshot in snapshots['Snapshots']:
        # Comprobar si el snapshot es más antiguo que el periodo de retención
        start_time = snapshot['StartTime'].replace(tzinfo=None)
        if start_time cutoff_date:
            ec2.delete_snapshot(SnapshotId=snapshot['SnapshotId'])
            deleted_count += 1
    
    return deleted_count

import boto3
import json
import os

sns = boto3.client('sns')
topic_arn = os.environ['SNS_TOPIC_ARN']
slack_webhook = os.environ.get('SLACK_WEBHOOK_URL')
teams_webhook = os.environ.get('TEAMS_WEBHOOK_URL')

def lambda_handler(event, context):
    # Extraer detalles del hallazgo de GuardDuty
    finding = event['detail']
    severity = finding['severity']
    title = finding['title']
    description = finding['description']
    finding_type = finding['type']
    resource = finding.get('resource', {})
    
    # Construir mensaje de alerta
    alert_message = f"""
    ⚠️ ALERTA DE SEGURIDAD: {title}
    
    Severidad: {severity}/10
    Tipo: {finding_type}
    
    Descripción: {description}
    
    Recursos afectados:
    """
    
    # Añadir detalles del recurso
    if 'instanceDetails' in resource:
        instance = resource['instanceDetails']
        alert_message += f"""
        - Instancia EC2: {instance.get('instanceId')}
          Nombre: {next((tag['value'] for tag in instance.get('tags', []) if tag['key'] == 'Name'), 'Sin nombre')}
          Tipo: {instance.get('instanceType')}
          VPC: {instance.get('vpcId')}
        """
    
    if 's3BucketDetails' in resource:
        bucket = resource['s3BucketDetails']
        alert_message += f"""
        - Bucket S3: {bucket.get('name')}
          ARN: {bucket.get('arn')}
        """
    
    # Enviar alerta a SNS
    sns.publish(
        TopicArn=topic_arn,
        Subject=f"Alerta de Seguridad: {title}",
        Message=alert_message
    )
    
    # Enviar a Slack si está configurado
    if slack_webhook:
        send_to_slack(title, alert_message, severity)
    
    # Enviar a Microsoft Teams si está configurado
    if teams_webhook:
        send_to_teams(title, alert_message, severity)
        
    return {
        'statusCode': 200,
        'body': json.dumps('Alerta enviada correctamente')
    }

def send_to_slack(title, message, severity):
    import urllib.request
    
    # Determinar color según severidad
    color = "#36a64f"  # Verde por defecto
    if severity >= 7:
        color = "#ff0000"  # Rojo para alta severidad
    elif severity >= 4:
        color = "#ffcc00"  # Amarillo para media severidad
    
    slack_message = {
        "attachments": [
            {
                "fallback": title,
                "color": color,
                "title": title,
                "text": message,
                "footer": "AWS GuardDuty via Lambda"
            }
        ]
    }
    
    req = urllib.request.Request(
        slack_webhook,
        data=json.dumps(slack_message).encode('utf-8'),
        headers={'Content-Type': 'application/json'}
    )
    
    with urllib.request.urlopen(req) as response:
        return response.read()

def send_to_teams(title, message, severity):
    import urllib.request
    
    teams_message = {
        "@type": "MessageCard",
        "@context": "http://schema.org/extensions",
        "themeColor": "0076D7",
        "summary": title,
        "sections": [{
            "activityTitle": f"⚠️ {title}",
            "activitySubtitle": f"Severidad: {severity}/10",
            "text": message
        }]
    }
    
    req = urllib.request.Request(
        teams_webhook,
        data=json.dumps(teams_message).encode('utf-8'),
        headers={'Content-Type': 'application/json'}
    )
    
    with urllib.request.urlopen(req) as response:
        return response.read()

{
  "Comment": "Procesamiento de pedido de e-commerce",
  "StartAt": "VerificarInventario",
  "States": {
    "VerificarInventario": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:verificarInventario",
      "Next": "DisponibilidadProducto",
      "Retry": [
        {
          "ErrorEquals": ["ServiceException", "ResourceNotFoundException"],
          "IntervalSeconds": 2,
          "MaxAttempts": 3,
          "BackoffRate": 1.5
        }
      ]
    },
    "DisponibilidadProducto": {
      "Type": "Choice",
      "Choices": [
        {
          "Variable": "$.disponible",
          "BooleanEquals": true,
          "Next": "ProcesarPago"
        }
      ],
      "Default": "NotificarProductoAgotado"
    },
    "ProcesarPago": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:procesarPago",
      "Next": "ResultadoPago",
      "Catch": [
        {
          "ErrorEquals": ["PaymentError"],
          "Next": "NotificarErrorPago"
        }
      ]
    },
    "ResultadoPago": {
      "Type": "Choice",
      "Choices": [
        {
          "Variable": "$.pagoExitoso",
          "BooleanEquals": true,
          "Next": "CrearOrden"
        }
      ],
      "Default": "NotificarErrorPago"
    },
    "CrearOrden": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:crearOrden",
      "Next": "NotificarConfirmacion"
    },
    "NotificarConfirmacion": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:notificarCliente",
      "Parameters": {
        "tipo": "confirmacion",
        "destinatario.$": "$.email",
        "ordenId.$": "$.ordenId"
      },
      "End": true
    },
    "NotificarProductoAgotado": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:notificarCliente",
      "Parameters": {
        "tipo": "agotado",
        "destinatario.$": "$.email",
        "producto.$": "$.productoId"
      },
      "End": true
    },
    "NotificarErrorPago": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:notificarCliente",
      "Parameters": {
        "tipo": "errorPago",
        "destinatario.$": "$.email",
        "error.$": "$.errorDetail"
      },
      "End": true
    }
  }
}

# Crear directorio para la capa
mkdir -p lambda-layer/python

# Instalar dependencias en el directorio
pip install requests pandas numpy boto3 -t lambda-layer/python

# Comprimir la capa
cd lambda-layer
zip -r ../layer-python-libs.zip .

# Subir la capa a AWS
aws lambda publish-layer-version \
    --layer-name python-common-libs \
    --description "Bibliotecas comunes: requests, pandas, numpy, boto3" \
    --zip-file fileb://../layer-python-libs.zip \
    --compatible-runtimes python3.8 python3.9 python3.10

# En serverless.yml
functions:
  procesarDatos:
    handler: handler.process_data
    layers:
      - !Ref PythonLibsLayer  # O el ARN completo de la capa
      
resources:
  Resources:
    PythonLibsLayer:
      Type: AWS::Lambda::LayerVersion
      Properties:
        LayerName: python-common-libs
        Description: Bibliotecas comunes para procesamiento de datos
        Content:
          S3Bucket: ${self:custom.layerBucket}
          S3Key: layer-python-libs.zip
        CompatibleRuntimes:
          - python3.8
          - python3.9
          - python3.10

# NO OPTIMIZADO
import boto3
import pandas as pd
import numpy as np
import json
import requests
import os

def lambda_handler(event, context):
    # Inicialización de clientes dentro del handler (ineficiente)
    s3 = boto3.client('s3')
    dynamodb = boto3.resource('dynamodb').Table('Datos')
    
    # Carga de configuración dentro del handler (ineficiente)
    config = json.loads(s3.get_object(
        Bucket='config-bucket',
        Key='config.json'
    )['Body'].read().decode('utf-8'))
    
    # Procesamiento con bibliotecas pesadas
    df = pd.DataFrame(json.loads(event['body']))
    result = process_data(df)
    
    # Guardar resultados
    dynamodb.put_item(Item={
        'id': context.aws_request_id,
        'data': result.to_json()
    })
    
    return {'statusCode': 200, 'body': 'Procesado'}

def process_data(df):
    # Procesamiento de datos con pandas
    return df.groupby('category').agg({'value': ['mean', 'sum', 'count']})

# OPTIMIZADO
import boto3
import pandas as pd
import numpy as np
import json
import requests
import os

# Inicialización global (fuera del handler)
s3 = boto3.client('s3')
dynamodb = boto3.resource('dynamodb').Table('Datos')

# Cargar configuración durante la inicialización
try:
    config_response = s3.get_object(
        Bucket='config-bucket',
        Key='config.json'
    )
    config = json.loads(config_response['Body'].read().decode('utf-8'))
except Exception as e:
    print(f"Error al cargar configuración: {e}")
    # Configuración por defecto en caso de error
    config = {"default_settings": True}

def lambda_handler(event, context):
    # Validación rápida de entrada
    if 'body' not in event:
        return {
            'statusCode': 400,
            'body': json.dumps({'error': 'Falta el cuerpo del evento'})
        }
    
    # Procesamiento usando módulos externos para operaciones costosas
    df = pd.DataFrame(json.loads(event['body']))
    result = process_data(df)
    
    # Guardar resultados con manejo de errores
    try:
        dynamodb.put_item(Item={
            'id': context.aws_request_id,
            'timestamp': int(time.time()),
            'data': result.to_json()
        })
    except Exception as e:
        print(f"Error al guardar datos: {e}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }
    
    return {
        'statusCode': 200,
        'body': json.dumps({'message': 'Procesado correctamente'})
    }

def process_data(df):
    # Función modularizada para procesamiento de datos
    # Usar operaciones vectorizadas de pandas en lugar de bucles
    return df.groupby('category').agg({'value': ['mean', 'sum', 'count']})

// Ejemplo de conexión persistente a MongoDB en Node.js
const mongoose = require('mongoose');
let conn = null;

exports.handler = async (event) => {
    // Reutilizar conexión existente o crear una nueva
    if (conn == null) {
        console.log('ESTABLECIENDO NUEVA CONEXIÓN A MONGODB');
        conn = await mongoose.connect(process.env.MONGODB_URI, {
            serverSelectionTimeoutMS: 5000
        });
    } else {
        console.log('REUTILIZANDO CONEXIÓN EXISTENTE');
    }
    
    // Resto del código.
};

# Crear alarma para errores en función Lambda
aws cloudwatch put-metric-alarm \
    --alarm-name lambda-errors-alarm \
    --alarm-description "Alarma para errores en función Lambda" \
    --metric-name Errors \
    --namespace AWS/Lambda \
    --statistic Sum \
    --period 60 \
    --threshold 5 \
    --comparison-operator GreaterThanOrEqualToThreshold \
    --dimensions Name=FunctionName,Value=mi-funcion-lambda \
    --evaluation-periods 1 \
    --alarm-actions arn:aws:sns:us-east-1:123456789012:alerts-topic

# AWS SAM template con despliegue canary
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./
      Handler: index.handler
      Runtime: nodejs16.x
      AutoPublishAlias: live
      DeploymentPreference:
        Type: Canary10Percent10Minutes
        Alarms:
          - !Ref AliasErrorMetricGreaterThanZeroAlarm
          - !Ref LatencyAlarm

# Ejemplo de Dockerfile para Lambda con Python
FROM public.ecr.aws/lambda/python:3.9

# Instalar dependencias
COPY requirements.txt .
RUN pip3 install -r requirements.txt

# Copiar código de función
COPY app.py .

# Especificar handler
CMD ["app.lambda_handler"]