← Back to the chapter · Previous detail · Next detail →

Technical detail · AMQP Operations: Deployment and Broker Health

Python consumer with Pika

import pika
import json
from typing import Callable

class AMQPConsumer:
    """Production-ready AMQP consumer with reliability features."""

    def __init__(self, host: str, queue: str, exchange: str,
                 binding_patterns: list, prefetch_count: int = 10):
        self.connection = pika.BlockingConnection(
            pika.ConnectionParameters(host=host)
        )
        self.channel = self.connection.channel()
        self.queue = queue

        # Declare durable queue with dead letter exchange
        self.channel.queue_declare(
            queue=queue,
            durable=True,
            arguments={
                'x-dead-letter-exchange': 'dlx',
                'x-dead-letter-routing-key': f'{queue}.failed'
            }
        )

        # Bind to exchange with patterns
        for pattern in binding_patterns:
            self.channel.queue_bind(
                exchange=exchange,
                queue=queue,
                routing_key=pattern
            )

        # Set prefetch for batching
        self.channel.basic_qos(prefetch_count=prefetch_count)

    def consume(self, callback: Callable):
        """
        Start consuming messages with manual acknowledgment.

        Args:
            callback: Function(body: dict) -> bool
                     Returns True if processed successfully
        """
        def on_message(channel, method, properties, body):
            try:
                message = json.loads(body)
                success = callback(message)

                if success:
                    channel.basic_ack(delivery_tag=method.delivery_tag)
                else:
                    # Requeue for retry
                    channel.basic_nack(
                        delivery_tag=method.delivery_tag,
                        requeue=True
                    )
            except Exception as e:
                print(f"Processing error: {e}")
                # Send to dead letter queue
                channel.basic_nack(
                    delivery_tag=method.delivery_tag,
                    requeue=False
                )

        self.channel.basic_consume(
            queue=self.queue,
            on_message_callback=on_message,
            auto_ack=False  # Manual acknowledgment
        )

        print(f"Consuming from {self.queue}...")
        self.channel.start_consuming()

# Usage example
def process_sensor_reading(message: dict) -> bool:
    """Process a sensor reading. Returns True if successful."""
    print(f"Received: {message}")
    # Your processing logic here
    return True

consumer = AMQPConsumer(
    host='localhost',
    queue='analytics',
    exchange='sensor-data',
    binding_patterns=['sensor.#'],
    prefetch_count=100  # Batch processing
)
consumer.consume(process_sensor_reading)

← Back to the chapter · Previous detail · Next detail →