Ejercicio: Sistema de Procesamiento con Contenedores, ALB y SQS ​

from flask import Flask, request, jsonify
import boto3
import os
import json
import logging

app = Flask(__name__)
sqs = boto3.client('sqs')
QUEUE_URL = os.environ['SQS_QUEUE_URL']

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@app.route('/health', methods=['GET'])
def health_check():
    return jsonify({"status": "healthy"}), 200

@app.route('/submit', methods=['POST'])
def submit_message():
    try:
        data = request.get_json()
        
        # Validar datos
        if not data or 'message' not in data:
            return jsonify({"error": "Invalid request"}), 400
        
        # Enviar mensaje a SQS
        response = sqs.send_message(
            QueueUrl=QUEUE_URL,
            MessageBody=json.dumps(data),
            MessageAttributes={
                'MessageType': {
                    'DataType': 'String',
                    'StringValue': 'ProcessingRequest'
                }
            }
        )
        
        logger.info(f"Message sent to SQS: {response['MessageId']}")
        
        return jsonify({
            "message": "Request submitted",
            "messageId": response['MessageId']
        }), 202
        
    except Exception as e:
        logger.error(f"Error processing request: {str(e)}")
        return jsonify({"error": str(e)}), 500

@app.route('/status', methods=['GET'])
def get_status():
    try:
        # Obtener atributos de la cola
        response = sqs.get_queue_attributes(
            QueueUrl=QUEUE_URL,
            AttributeNames=['ApproximateNumberOfMessages']
        )
        
        return jsonify({
            "queueSize": response['Attributes']['ApproximateNumberOfMessages']
        }), 200
        
    except Exception as e:
        logger.error(f"Error getting status: {str(e)}")
        return jsonify({"error": str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80)

import boto3
import json
import os
import logging
import time
from botocore.exceptions import ClientError

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

sqs = boto3.client('sqs')
QUEUE_URL = os.environ['SQS_QUEUE_URL']

def process_message(message_body):
    """
    Procesa el mensaje. Aquí irías la lógica de negocio.
    """
    try:
        data = json.loads(message_body)
        logger.info(f"Processing message: {data}")
        # Simular procesamiento
        time.sleep(2)
        return True
    except Exception as e:
        logger.error(f"Error processing message: {str(e)}")
        return False

def main():
    while True:
        try:
            # Recibir mensajes de SQS
            response = sqs.receive_message(
                QueueUrl=QUEUE_URL,
                MaxNumberOfMessages=10,
                WaitTimeSeconds=20,
                MessageAttributeNames=['All']
            )

            if 'Messages' in response:
                for message in response['Messages']:
                    logger.info(f"Received message: {message['MessageId']}")
                    
                    # Procesar mensaje
                    if process_message(message['Body']):
                        # Eliminar mensaje si se procesó correctamente
                        sqs.delete_message(
                            QueueUrl=QUEUE_URL,
                            ReceiptHandle=message['ReceiptHandle']
                        )
                        logger.info(f"Message processed and deleted: {message['MessageId']}")
                    else:
                        logger.error(f"Failed to process message: {message['MessageId']}")
                        
        except ClientError as e:
            logger.error(f"AWS error: {str(e)}")
            time.sleep(5)
        except Exception as e:
            logger.error(f"Unexpected error: {str(e)}")
            time.sleep(5)

if __name__ == '__main__':
    main()