🔄 RPC Pattern

Le pattern RPC (Remote Procedure Call) avec RabbitMQ permet d'implémenter des appels de procédures distantes asynchrones tout en conservant les avantages de la messagerie (persistance, load balancing, monitoring).

🎯 Principe

💻 Implémentation

Client RPC

class RPCClient {
    constructor() {
        this.pendingRequests = new Map();
    }
    
    async call(method, params, timeout = 30000) {
        const correlationId = uuid();
        const replyQueue = await this.channel.assertQueue('', {exclusive: true});
        
        return new Promise((resolve, reject) => {
            const timer = setTimeout(() => {
                this.pendingRequests.delete(correlationId);
                reject(new Error('RPC timeout'));
            }, timeout);
            
            this.pendingRequests.set(correlationId, {resolve, reject, timer});
            
            this.channel.publish('', 'rpc_queue', Buffer.from(JSON.stringify({
                method, params
            })), {
                correlationId,
                replyTo: replyQueue.queue
            });
        });
    }
}

Server RPC

def rpc_server():
    def process_request(ch, method, props, body):
        try:
            request = json.loads(body)
            result = handle_rpc_call(request['method'], request['params'])
            
            # Répondre avec même correlation_id
            ch.basic_publish(
                exchange='',
                routing_key=props.reply_to,
                body=json.dumps(result),
                properties=pika.BasicProperties(
                    correlation_id=props.correlation_id
                )
            )
            ch.basic_ack(delivery_tag=method.delivery_tag)
            
        except Exception as e:
            ch.basic_reject(delivery_tag=method.delivery_tag, requeue=False)
    
    channel.basic_consume(queue='rpc_queue', on_message_callback=process_request)
    channel.start_consuming()

Le pattern RPC combine la simplicité des appels de fonction avec la robustesse de la messagerie asynchrone.