Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHDERUPTENFRES

Elysia Tools

Navegación

Mensajería

Ejemplos de RocketMQ Message Queue

Ejemplos de Apache RocketMQ incluyendo productores, consumidores, mensajes ordenados, mensajes retrasados, consumo de difusión y mensajes transaccionales para mensajería de alto rendimiento

Ejemplos

Entradas de esta colección

CódigojavascriptSimple

RocketMQ Hello World - Productor/Consumidor Básico

Ejemplo simple de productor y consumidor Apache RocketMQ demostrando operaciones básicas de cola de mensajes

Dificultad

2/10

Tiempo estimado

10 min

Etiquetas

rocketmq, messaging, beginner

Requisitos previos

RocketMQ server running, Node.js

javascript
// RocketMQ Hello World - Basic Producer/Consumer Example
// Install: npm install apache-rocketmq

const { Producer, Consumer, MessageModel } = require('apache-rocketmq');

async function helloWorld() {
  // RocketMQ configuration
  const config = {
    endpoints: 'localhost:9876',
    accessKey: 'rocketmq',
    secretKey: '12345678',
    instanceName: 'hello-world-example',
  };

  console.log('=== RocketMQ Hello World Example ===');

  // Create consumer
  const consumer = new Consumer({
    ...config,
    consumerGroup: 'hello-consumer-group',
    topic: 'hello-topic',
    tag: '*',
    messageModel: MessageModel.CLUSTERING,
  });

  // Create producer
  const producer = new Producer({
    ...config,
    producerGroup: 'hello-producer-group',
  });

  // Start consumer
  console.log('Starting consumer...');
  await consumer.start();

  // Set up message listener
  consumer.subscribe((msg, ack) => {
    console.log(`Received message: ${msg.body.toString()}`);
    console.log(`Message ID: ${msg.id}`);
    console.log(`Topic: ${msg.topic}`);
    console.log(`Tag: ${msg.tag}`);
    console.log('---');

    // Acknowledge message
    ack();
  });

  // Start producer
  console.log('Starting producer...');
  await producer.start();

  // Wait a moment for consumer to be ready
  await new Promise(resolve => setTimeout(resolve, 2000));

  // Send messages
  console.log('Sending messages...');
  const messages = [
    'Hello RocketMQ!',
    'Apache RocketMQ is powerful!',
    'Message queue made easy!',
    'High performance messaging!',
  ];

  for (let i = 0; i < messages.length; i++) {
    const message = {
      topic: 'hello-topic',
      tag: 'hello',
      body: Buffer.from(messages[i]),
      keys: ['key-' + (i + 1)],
      properties: {
        source: 'hello-world-example',
        timestamp: new Date().toISOString(),
      },
    };

    const result = await producer.send(message);
    console.log(`Message sent: ${messages[i]}`);
    console.log(`Message ID: ${result.messageId}`);
    console.log('---');
  }

  // Wait for messages to be consumed
  console.log('Waiting for messages to be consumed...');
  await new Promise(resolve => setTimeout(resolve, 5000));

  // Shutdown
  console.log('Shutting down...');
  await producer.shutdown();
  await consumer.shutdown();

  console.log('RocketMQ Hello World example completed!');
}

helloWorld().catch(err => {
  console.error('Error:', err);
});
CódigojavascriptIntermedio

Mensajes Ordenados RocketMQ

Implementar entrega de mensajes ordenados usando claves de partición con colas de mensajes

Dificultad

6/10

Tiempo estimado

20 min

Etiquetas

rocketmq, ordered, sequencing

Requisitos previos

RocketMQ server running, Node.js, RocketMQ basics

javascript
// RocketMQ Ordered Messages Example
// Ensures message order within the same sharding key

const { Producer, Consumer, MessageModel } = require('apache-rocketmq');

// Order event producer
async function orderEventProducer() {
  const producer = new Producer({
    endpoints: 'localhost:9876',
    producerGroup: 'order-producer-group',
    instanceName: 'order-event-producer',
  });

  await producer.start();
  console.log('Order event producer started');

  // Simulate order events for multiple users
  const orders = [
    // User 1 - Order lifecycle (should be processed in order)
    { userId: 'user001', orderId: 'ORD001', event: 'order.created', amount: 99.99 },
    { userId: 'user001', orderId: 'ORD001', event: 'payment.processed', amount: 99.99 },
    { userId: 'user001', orderId: 'ORD001', event: 'order.confirmed', amount: 99.99 },
    { userId: 'user001', orderId: 'ORD001', event: 'order.shipped', amount: 99.99 },
    { userId: 'user001', orderId: 'ORD001', event: 'order.delivered', amount: 99.99 },

    // User 2 - Order lifecycle (should be processed in order)
    { userId: 'user002', orderId: 'ORD002', event: 'order.created', amount: 149.99 },
    { userId: 'user002', orderId: 'ORD002', event: 'payment.processed', amount: 149.99 },
    { userId: 'user002', orderId: 'ORD002', event: 'order.confirmed', amount: 149.99 },

    // User 3 - Order lifecycle (should be processed in order)
    { userId: 'user003', orderId: 'ORD003', event: 'order.created', amount: 79.99 },
    { userId: 'user003', orderId: 'ORD003', event: 'payment.failed', amount: 79.99 },
    { userId: 'user003', orderId: 'ORD003', event: 'order.cancelled', amount: 79.99 },

    // More events for user 1 and 2
    { userId: 'user001', orderId: 'ORD004', event: 'order.created', amount: 199.99 },
    { userId: 'user002', orderId: 'ORD005', event: 'order.created', amount: 59.99 },
  ];

  console.log('Sending order events...');
  for (let i = 0; i < orders.length; i++) {
    const order = orders[i];

    const message = {
      topic: 'order-events',
      tag: order.event,
      body: Buffer.from(JSON.stringify({
        ...order,
        timestamp: new Date().toISOString(),
        sequence: i + 1,
      })),
      // Use userId as sharding key to ensure order for each user
      shardingKey: order.userId,
      keys: [order.orderId, order.userId],
      properties: {
        eventType: order.event,
        userId: order.userId,
        orderId: order.orderId,
      },
    };

    const result = await producer.send(message);
    console.log(`[${order.userId}] ${order.event}: ${order.orderId} (Message ID: ${result.messageId})`);

    // Small delay to simulate real-world scenario
    await new Promise(resolve => setTimeout(resolve, 100));
  }

  await producer.shutdown();
  console.log('Order event producer stopped');
}

// Order event consumer with ordered processing
async function orderEventConsumer(consumerId) {
  const consumer = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: `order-consumer-group-${consumerId}`,
    topic: 'order-events',
    tag: '*',
    messageModel: MessageModel.CLUSTERING,
    instanceName: `order-consumer-${consumerId}`,
    // Enable ordered message consumption
    orderly: true,
  });

  await consumer.start();
  console.log(`Order event consumer ${consumerId} started`);

  // Track order states for each user
  const orderStates = new Map();

  consumer.subscribe((msg, ack) => {
    try {
      const orderEvent = JSON.parse(msg.body.toString());

      console.log(`[CONSUMER ${consumerId}] Processing: ${orderEvent.userId} -> ${orderEvent.event}`);

      // Validate order sequence for each user
      const userState = orderStates.get(orderEvent.userId) || { lastEvent: null, expectedEvent: 'order.created' };

      // Simple order state validation
      const validTransitions = {
        'order.created': ['payment.processed', 'payment.failed'],
        'payment.processed': ['order.confirmed'],
        'payment.failed': ['order.cancelled'],
        'order.confirmed': ['order.shipped'],
        'order.shipped': ['order.delivered'],
        'order.cancelled': ['order.created'], // Can create new order after cancellation
        'order.delivered': ['order.created'], // Can create new order after delivery
      };

      if (userState.lastEvent) {
        const allowedNextEvents = validTransitions[userState.lastEvent] || [];
        if (!allowedNextEvents.includes(orderEvent.event)) {
          console.log(`[CONSUMER ${consumerId}] WARNING: Invalid order transition for ${orderEvent.userId}: ${userState.lastEvent} -> ${orderEvent.event}`);
        }
      }

      // Update order state
      orderStates.set(orderEvent.userId, {
        lastEvent: orderEvent.event,
        lastOrderId: orderEvent.orderId,
      });

      console.log(`[CONSUMER ${consumerId}] Processed: ${orderEvent.userId} -> ${orderEvent.event} -> ${orderEvent.orderId}`);
      console.log(`[CONSUMER ${consumerId}] Current state for ${orderEvent.userId}: ${orderStates.get(orderEvent.userId).lastEvent}`);
      console.log('---');

      // Acknowledge message
      ack();
    } catch (err) {
      console.error(`[CONSUMER ${consumerId}] Error processing message:`, err);
      ack(); // Acknowledge even on error to avoid blocking the queue
    }
  });

  return consumer;
}

// Demo ordered vs unordered messages
async function demoOrderingComparison() {
  console.log('\n=== Ordered vs Unordered Comparison ===');

  // Unordered producer (random order)
  const unorderedProducer = new Producer({
    endpoints: 'localhost:9876',
    producerGroup: 'unordered-producer-group',
    instanceName: 'unordered-producer',
  });

  await unorderedProducer.start();

  console.log('Sending unordered messages...');
  const unorderedMessages = ['A', 'B', 'C', 'D', 'E'];

  for (const msg of unorderedMessages) {
    await unorderedProducer.send({
      topic: 'unordered-test',
      body: Buffer.from(`Unordered message: ${msg}`),
    });
    console.log(`Sent unordered: ${msg}`);
  }

  await unorderedProducer.shutdown();
}

// Main function
async function main() {
  console.log('=== RocketMQ Ordered Messages Example ===');

  try {
    // Step 1: Start multiple consumers to show load balancing
    console.log('\n1. Starting consumers...');
    const consumers = [];
    for (let i = 1; i <= 3; i++) {
      consumers.push(await orderEventConsumer(i));
    }

    // Step 2: Wait for consumers to be ready
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Step 3: Start producer to send ordered messages
    console.log('\n2. Sending ordered messages...');
    const producerPromise = orderEventProducer();

    // Step 4: Wait for message processing
    await producerPromise;
    console.log('\n3. Waiting for message processing...');
    await new Promise(resolve => setTimeout(resolve, 8000));

    // Step 5: Demo comparison
    await demoOrderingComparison();

    // Step 6: Shutdown
    console.log('\n4. Shutting down consumers...');
    for (const consumer of consumers) {
      await consumer.shutdown();
    }

    console.log('Ordered messages example completed!');
  } catch (err) {
    console.error('Error in ordered messages example:', err);
  }
}

main().catch(err => {
  console.error('Error:', err);
});
CódigojavascriptIntermedio

Mensajes Retrasados RocketMQ

Implementar entrega de mensajes retrasados y programados usando la función de retraso incorporada de RocketMQ

Dificultad

6/10

Tiempo estimado

25 min

Etiquetas

rocketmq, delayed, scheduled, timing

Requisitos previos

RocketMQ server running, Node.js, RocketMQ basics

javascript
// RocketMQ Delayed Messages Example
// Demonstrates various types of delayed and scheduled message delivery

const { Producer, Consumer, MessageModel } = require('apache-rocketmq');

// Delay levels in RocketMQ (seconds)
// 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
const DELAY_LEVELS = {
  '1s': 1,
  '5s': 2,
  '10s': 3,
  '30s': 4,
  '1m': 5,
  '2m': 6,
  '3m': 7,
  '4m': 8,
  '5m': 9,
  '6m': 10,
  '7m': 11,
  '8m': 12,
  '9m': 13,
  '10m': 14,
  '20m': 15,
  '30m': 16,
  '1h': 17,
  '2h': 18,
};

// Reminder service producer
async function reminderProducer() {
  const producer = new Producer({
    endpoints: 'localhost:9876',
    producerGroup: 'reminder-producer-group',
    instanceName: 'reminder-producer',
  });

  await producer.start();
  console.log('Reminder producer started');

  // Different types of reminders with various delays
  const reminders = [
    {
      id: 'rem001',
      type: 'meeting',
      message: 'Team standup meeting starts now!',
      delay: '10s',
      recipient: 'team@example.com',
    },
    {
      id: 'rem002',
      type: 'deadline',
      message: 'Project submission deadline approaching!',
      delay: '1m',
      recipient: 'developer@example.com',
    },
    {
      id: 'rem003',
      type: 'birthday',
      message: 'Happy birthday! Don't forget to wish them well!',
      delay: '2m',
      recipient: 'hr@example.com',
    },
    {
      id: 'rem004',
      type: 'maintenance',
      message: 'System maintenance scheduled for tonight',
      delay: '5m',
      recipient: 'ops@example.com',
    },
    {
      id: 'rem005',
      type: 'follow-up',
      message: 'Follow up with client about proposal',
      delay: '30s',
      recipient: 'sales@example.com',
    },
  ];

  console.log('Sending delayed reminders...');
  const sendTime = new Date();

  for (const reminder of reminders) {
    const delayLevel = DELAY_LEVELS[reminder.delay];
    if (!delayLevel) {
      console.log(`Warning: Unknown delay level '${reminder.delay}' for reminder ${reminder.id}`);
      continue;
    }

    const message = {
      topic: 'reminder-topic',
      tag: reminder.type,
      body: Buffer.from(JSON.stringify({
        ...reminder,
        scheduledAt: sendTime.toISOString(),
        delayLevel: delayLevel,
        expectedAt: new Date(sendTime.getTime() + (delayLevel * 1000)).toISOString(),
      })),
      keys: [reminder.id],
      properties: {
        reminderId: reminder.id,
        reminderType: reminder.type,
        delay: reminder.delay,
        delayLevel: delayLevel.toString(),
        scheduledAt: sendTime.toISOString(),
      },
      // Set delay level
      delayTimeLevel: delayLevel,
    };

    const result = await producer.send(message);
    console.log(`[${reminder.delay.padEnd(3)}] ${reminder.type.padEnd(12)} -> ${reminder.recipient.padEnd(25)} (ID: ${reminder.id})`);
    console.log(`      Expected at: ${new Date(sendTime.getTime() + (delayLevel * 1000)).toLocaleTimeString()}`);
    console.log(`      Message ID: ${result.messageId}`);
    console.log('---');
  }

  await producer.shutdown();
  console.log('Reminder producer stopped');
}

// Notification service for handling reminders
async function reminderConsumer() {
  const consumer = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'reminder-consumer-group',
    topic: 'reminder-topic',
    tag: '*',
    messageModel: MessageModel.CLUSTERING,
    instanceName: 'reminder-consumer',
  });

  await consumer.start();
  console.log('Reminder consumer started');

  consumer.subscribe((msg, ack) => {
    try {
      const reminder = JSON.parse(msg.body.toString());
      const receivedTime = new Date();
      const scheduledTime = new Date(reminder.scheduledAt);
      const expectedTime = new Date(reminder.expectedAt);
      const actualDelay = (receivedTime.getTime() - scheduledTime.getTime()) / 1000;
      const expectedDelay = (expectedTime.getTime() - scheduledTime.getTime()) / 1000;

      console.log('\n🔔 REMINDER RECEIVED!');
      console.log(`   ID: ${reminder.id}`);
      console.log(`   Type: ${reminder.type}`);
      console.log(`   Recipient: ${reminder.recipient}`);
      console.log(`   Message: ${reminder.message}`);
      console.log(`   Scheduled: ${scheduledTime.toLocaleTimeString()}`);
      console.log(`   Expected:   ${expectedTime.toLocaleTimeString()}`);
      console.log(`   Received:   ${receivedTime.toLocaleTimeString()}`);
      console.log(`   Delay: ${actualDelay.toFixed(2)}s (expected: ${expectedDelay}s)`);
      console.log(`   Accuracy: ${Math.abs(actualDelay - expectedDelay) < 1 ? '✓ Good' : '⚠ Delayed'}`);
      console.log('---');

      // Here you would send actual notification (email, SMS, push notification, etc.)
      // For demo purposes, we just log it

      ack();
    } catch (err) {
      console.error('Error processing reminder:', err);
      ack();
    }
  });

  return consumer;
}

// Order cancellation with grace period
async function orderCancellationDemo() {
  console.log('\n=== Order Cancellation with Grace Period ===');

  const producer = new Producer({
    endpoints: 'localhost:9876',
    producerGroup: 'order-cancellation-producer',
    instanceName: 'order-cancellation-producer',
  });

  await producer.start();

  // Create an order
  const order = {
    orderId: 'ORD-CANCEL-001',
    userId: 'user-cancel-demo',
    amount: 299.99,
    items: ['Premium Widget', 'Extended Warranty'],
    createdAt: new Date().toISOString(),
  };

  console.log(`Creating order: ${order.orderId}`);

  // Send order created message
  await producer.send({
    topic: 'order-lifecycle',
    tag: 'order.created',
    body: Buffer.from(JSON.stringify(order)),
    keys: [order.orderId],
  });

  // Send delayed cancellation check
  const cancellationCheck = {
    orderId: order.orderId,
    userId: order.userId,
    type: 'auto-cancel-check',
    scheduledAt: new Date().toISOString(),
    gracePeriod: '30s',
  };

  await producer.send({
    topic: 'order-lifecycle',
    tag: 'cancellation.check',
    body: Buffer.from(JSON.stringify(cancellationCheck)),
    keys: [order.orderId, 'cancel-check'],
    delayTimeLevel: DELAY_LEVELS['30s'], // Check after 30 seconds
  });

  console.log(`Scheduled cancellation check for ${order.orderId} in 30s`);

  await producer.shutdown();
}

// Lifecycle consumer for orders
async function orderLifecycleConsumer() {
  const consumer = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'order-lifecycle-consumer',
    topic: 'order-lifecycle',
    tag: '*',
    messageModel: MessageModel.CLUSTERING,
    instanceName: 'order-lifecycle-consumer',
  });

  await consumer.start();

  // Track order states
  const orderStates = new Map();

  consumer.subscribe((msg, ack) => {
    try {
      if (msg.tag === 'cancellation.check') {
        const check = JSON.parse(msg.body.toString());
        console.log(`\n⏰ CANCELLATION CHECK FOR ORDER: ${check.orderId}`);

        // In a real system, you would check if payment was received
        // For demo, we'll randomly decide to cancel or not
        const shouldCancel = Math.random() > 0.5;

        if (shouldCancel) {
          console.log(`   → Cancelling unpaid order ${check.orderId}`);
          // Here you would send a cancellation message
        } else {
          console.log(`   → Order ${check.orderId} is confirmed`);
          // Here you might schedule fulfillment
        }
      } else {
        const order = JSON.parse(msg.body.toString());
        console.log(`📦 Order Event: ${msg.tag} -> ${order.orderId}`);
        orderStates.set(order.orderId, msg.tag);
      }

      ack();
    } catch (err) {
      console.error('Error in lifecycle consumer:', err);
      ack();
    }
  });

  return consumer;
}

// Main function
async function main() {
  console.log('=== RocketMQ Delayed Messages Example ===');

  try {
    // Step 1: Start consumers
    console.log('\n1. Starting consumers...');
    const reminderConsumerPromise = reminderConsumer();
    const orderLifecyclePromise = orderLifecycleConsumer();

    // Step 2: Wait for consumers to be ready
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Step 3: Send reminders
    console.log('\n2. Sending delayed reminders...');
    await reminderProducer();

    // Step 4: Demo order cancellation
    await new Promise(resolve => setTimeout(resolve, 1000));
    await orderCancellationDemo();

    // Step 5: Wait for all delayed messages to be processed
    console.log('\n3. Waiting for delayed messages to be delivered...');
    await new Promise(resolve => setTimeout(resolve, 35000)); // Wait for longest delay (2m + buffer)

    // Step 6: Shutdown consumers
    console.log('\n4. Shutting down consumers...');
    const reminderConsumer = await reminderConsumerPromise;
    const orderConsumer = await orderLifecyclePromise;
    await reminderConsumer.shutdown();
    await orderConsumer.shutdown();

    console.log('Delayed messages example completed!');
  } catch (err) {
    console.error('Error in delayed messages example:', err);
  }
}

main().catch(err => {
  console.error('Error:', err);
});
CódigojavascriptComplejo

Mensajes Transaccionales RocketMQ

Implementar transacciones distribuidas usando la función de mensajes transaccionales de RocketMQ para consistencia eventual

Dificultad

9/10

Tiempo estimado

30 min

Etiquetas

rocketmq, transaction, distributed, acid

Requisitos previos

RocketMQ server running, Node.js, Advanced RocketMQ knowledge, Understanding of distributed transactions

javascript
// RocketMQ Transactional Messages Example
// Demonstrates distributed transactions with local and remote operations

const { Producer, Consumer, MessageModel, TransactionMQProducer } = require('apache-rocketmq');

// Simulated database for orders
class OrderDatabase {
  constructor() {
    this.orders = new Map();
    this.payments = new Map();
    this.inventories = new Map();
  }

  async createOrder(order) {
    console.log(`[DB] Creating order: ${order.orderId}`);
    // Simulate database operation
    await new Promise(resolve => setTimeout(resolve, 100));
    this.orders.set(order.orderId, { ...order, status: 'created' });
    return true;
  }

  async processPayment(payment) {
    console.log(`[DB] Processing payment: ${payment.paymentId}`);
    // Simulate payment processing
    await new Promise(resolve => setTimeout(resolve, 200));

    // Simulate occasional payment failures
    if (Math.random() < 0.2) {
      console.log(`[DB] Payment failed: ${payment.paymentId}`);
      return false;
    }

    this.payments.set(payment.paymentId, { ...payment, status: 'completed' });
    return true;
  }

  async updateInventory(inventoryUpdate) {
    console.log(`[DB] Updating inventory for: ${inventoryUpdate.productId}`);
    // Simulate inventory update
    await new Promise(resolve => setTimeout(resolve, 50));
    this.inventories.set(inventoryUpdate.productId, inventoryUpdate);
    return true;
  }

  async rollbackOrder(orderId) {
    console.log(`[DB] Rolling back order: ${orderId}`);
    const order = this.orders.get(orderId);
    if (order) {
      order.status = 'cancelled';
      this.orders.set(orderId, order);
    }
  }

  getOrderStatus(orderId) {
    const order = this.orders.get(orderId);
    return order ? order.status : 'not_found';
  }
}

// Transactional producer for order processing
async function createTransactionalProducer() {
  const producer = new TransactionMQProducer({
    endpoints: 'localhost:9876',
    producerGroup: 'order-transaction-producer',
    instanceName: 'order-transaction-producer',
    // Transaction check listener
    checkListener: async (msg) => {
      try {
        const transactionId = msg.properties.transactionId;
        const orderData = JSON.parse(msg.body.toString());

        console.log(`[TRANSACTION CHECK] Checking transaction ${transactionId} for order ${orderData.orderId}`);

        // Check local transaction status
        // In real application, you would query your database
        const orderStatus = global.orderDB.getOrderStatus(orderData.orderId);

        console.log(`[TRANSACTION CHECK] Order ${orderData.orderId} status: ${orderStatus}`);

        // Return transaction status
        if (orderStatus === 'created' || orderStatus === 'processing') {
          return { state: 'COMMIT' };
        } else if (orderStatus === 'cancelled') {
          return { state: 'ROLLBACK' };
        } else {
          return { state: 'UNKNOWN' };
        }
      } catch (err) {
        console.error('Transaction check error:', err);
        return { state: 'UNKNOWN' };
      }
    },
  });

  await producer.start();
  console.log('Transactional producer started');
  return producer;
}

// Order service with transactional messaging
class OrderService {
  constructor(producer, database) {
    this.producer = producer;
    this.db = database;
  }

  async processOrder(orderRequest) {
    const transactionId = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    console.log(`\n🔄 Starting transaction ${transactionId} for order ${orderRequest.orderId}`);

    // Step 1: Send half message (prepared message)
    const halfMessage = {
      topic: 'order-events',
      tag: 'order.created',
      body: Buffer.from(JSON.stringify({
        ...orderRequest,
        transactionId: transactionId,
        timestamp: new Date().toISOString(),
      })),
      keys: [orderRequest.orderId, transactionId],
      properties: {
        transactionId: transactionId,
        orderId: orderRequest.orderId,
      },
    };

    console.log(`[1/4] Sending half message for order ${orderRequest.orderId}`);
    const sendResult = await this.producer.sendTransactionMessage(halfMessage);

    try {
      // Step 2: Execute local transaction
      console.log(`[2/4] Executing local transaction for order ${orderRequest.orderId}`);

      const localTxSuccess = await this.executeLocalTransaction(orderRequest, transactionId);

      if (localTxSuccess) {
        // Step 3: Commit transaction
        console.log(`[3/4] Committing transaction ${transactionId}`);
        await this.producer.commitTransaction(sendResult.transactionId);
        console.log(`[4/4] ✅ Transaction ${transactionId} COMMITTED for order ${orderRequest.orderId}`);
        return { success: true, transactionId };
      } else {
        // Step 4: Rollback transaction
        console.log(`[3/4] Rolling back transaction ${transactionId}`);
        await this.producer.rollbackTransaction(sendResult.transactionId);
        console.log(`[4/4] ❌ Transaction ${transactionId} ROLLED BACK for order ${orderRequest.orderId}`);
        return { success: false, transactionId };
      }
    } catch (err) {
      console.error(`Local transaction failed for ${transactionId}:`, err);
      console.log(`[3/4] Rolling back transaction ${transactionId} due to error`);
      await this.producer.rollbackTransaction(sendResult.transactionId);
      throw err;
    }
  }

  async executeLocalTransaction(orderRequest, transactionId) {
    try {
      // Create order in local database
      const orderSuccess = await this.db.createOrder({
        ...orderRequest,
        status: 'processing',
        transactionId: transactionId,
      });

      if (!orderSuccess) {
        await this.db.rollbackOrder(orderRequest.orderId);
        return false;
      }

      // Process payment
      const paymentSuccess = await this.db.processPayment({
        paymentId: `pay_${orderRequest.orderId}`,
        orderId: orderRequest.orderId,
        amount: orderRequest.amount,
        transactionId: transactionId,
      });

      if (!paymentSuccess) {
        await this.db.rollbackOrder(orderRequest.orderId);
        return false;
      }

      // Update inventory
      for (const item of orderRequest.items) {
        const inventorySuccess = await this.db.updateInventory({
          productId: item.productId,
          quantity: -item.quantity, // Decrease inventory
          orderId: orderRequest.orderId,
          transactionId: transactionId,
        });

        if (!inventorySuccess) {
          await this.db.rollbackOrder(orderRequest.orderId);
          return false;
        }
      }

      // Mark order as completed
      const order = this.db.orders.get(orderRequest.orderId);
      order.status = 'completed';
      this.db.orders.set(orderRequest.orderId, order);

      console.log(`[LOCAL TX] All operations completed for order ${orderRequest.orderId}`);
      return true;

    } catch (err) {
      console.error(`[LOCAL TX] Error executing transaction for order ${orderRequest.orderId}:`, err);
      await this.db.rollbackOrder(orderRequest.orderId);
      return false;
    }
  }
}

// Order event consumer
async function orderEventConsumer() {
  const consumer = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'order-event-consumer',
    topic: 'order-events',
    tag: '*',
    messageModel: MessageModel.BROADCASTING, // All consumers get all messages
    instanceName: 'order-event-consumer',
  });

  await consumer.start();
  console.log('Order event consumer started');

  consumer.subscribe((msg, ack) => {
    try {
      const orderEvent = JSON.parse(msg.body.toString());
      const now = new Date();

      console.log('\n📦 ORDER EVENT RECEIVED');
      console.log(`   Order ID: ${orderEvent.orderId}`);
      console.log(`   Transaction ID: ${orderEvent.transactionId}`);
      console.log(`   Amount: $${orderEvent.amount}`);
      console.log(`   Items: ${orderEvent.items.map(i => i.productId).join(', ')}`);
      console.log(`   Created At: ${new Date(orderEvent.timestamp).toLocaleTimeString()}`);
      console.log(`   Received At: ${now.toLocaleTimeString()}`);
      console.log(`   Processing Delay: ${(now.getTime() - new Date(orderEvent.timestamp).getTime())}ms`);

      // Here you would:
      // 1. Update search indexes
      // 2. Send notifications
      // 3. Update analytics
      // 4. Trigger other downstream services
      console.log('   → Processing downstream services...');

      // Simulate downstream processing
      setTimeout(() => {
        console.log(`   → Downstream processing completed for ${orderEvent.orderId}`);
      }, 100);

      console.log('---');
      ack();
    } catch (err) {
      console.error('Error processing order event:', err);
      ack();
    }
  });

  return consumer;
}

// Payment verification service (consumer)
async function paymentVerificationConsumer() {
  const consumer = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'payment-verification-consumer',
    topic: 'order-events',
    tag: 'order.created',
    messageModel: MessageModel.CLUSTERING,
    instanceName: 'payment-verification-consumer',
  });

  await consumer.start();
  console.log('Payment verification consumer started');

  consumer.subscribe((msg, ack) => {
    try {
      const orderEvent = JSON.parse(msg.body.toString());

      console.log(`\n💳 Payment verification for order ${orderEvent.orderId}`);

      // In a real system, you might:
      // 1. Verify payment with external payment gateway
      // 2. Update fraud detection systems
      // 3. Send payment confirmation to customer

      const paymentStatus = Math.random() > 0.1 ? 'VERIFIED' : 'REQUIRES_REVIEW';
      console.log(`   → Payment status: ${paymentStatus}`);

      if (paymentStatus === 'REQUIRES_REVIEW') {
        console.log(`   → Order ${orderEvent.orderId} flagged for manual review`);
      }

      ack();
    } catch (err) {
      console.error('Error in payment verification:', err);
      ack();
    }
  });

  return consumer;
}

// Main function
async function main() {
  console.log('=== RocketMQ Transactional Messages Example ===');

  // Initialize database
  global.orderDB = new OrderDatabase();

  try {
    // Step 1: Create transactional producer
    console.log('\n1. Setting up transactional producer...');
    const producer = await createTransactionalProducer();

    // Step 2: Start consumers
    console.log('\n2. Starting consumers...');
    const orderConsumerPromise = orderEventConsumer();
    const paymentConsumerPromise = paymentVerificationConsumer();

    // Step 3: Wait for consumers to be ready
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Step 4: Create order service
    console.log('\n3. Creating order service...');
    const orderService = new OrderService(producer, global.orderDB);

    // Step 5: Process multiple orders
    console.log('\n4. Processing orders...');
    const orders = [
      {
        orderId: 'TX-ORDER-001',
        userId: 'user-tx-001',
        amount: 299.99,
        items: [
          { productId: 'LAPTOP-001', quantity: 1, price: 199.99 },
          { productId: 'MOUSE-001', quantity: 1, price: 49.99 },
          { productId: 'KEYBOARD-001', quantity: 1, price: 50.01 },
        ],
      },
      {
        orderId: 'TX-ORDER-002',
        userId: 'user-tx-002',
        amount: 149.99,
        items: [
          { productId: 'MONITOR-001', quantity: 1, price: 149.99 },
        ],
      },
      {
        orderId: 'TX-ORDER-003',
        userId: 'user-tx-003',
        amount: 89.97,
        items: [
          { productId: 'HEADPHONE-001', quantity: 2, price: 44.99 },
        ],
      },
    ];

    // Process orders with delays
    for (let i = 0; i < orders.length; i++) {
      const order = orders[i];
      console.log(`\n--- Processing Order ${i + 1}/${orders.length} ---`);

      const result = await orderService.processOrder(order);

      if (result.success) {
        console.log(`✅ Order ${order.orderId} processed successfully`);
      } else {
        console.log(`❌ Order ${order.orderId} processing failed`);
      }

      // Wait between orders
      if (i < orders.length - 1) {
        await new Promise(resolve => setTimeout(resolve, 3000));
      }
    }

    // Step 6: Wait for message processing
    console.log('\n5. Waiting for message processing...');
    await new Promise(resolve => setTimeout(resolve, 10000));

    // Step 7: Shutdown
    console.log('\n6. Shutting down...');
    await producer.shutdown();

    const orderConsumer = await orderConsumerPromise;
    const paymentConsumer = await paymentConsumerPromise;
    await orderConsumer.shutdown();
    await paymentConsumer.shutdown();

    console.log('\nTransactional messages example completed!');
    console.log('\nSummary:');
    console.log('- Demonstrated distributed transactions with local DB ops and remote messaging');
    console.log('- Transaction consistency maintained even with failures');
    console.log('- Downstream services only receive committed transactions');
  } catch (err) {
    console.error('Error in transactional messages example:', err);
  }
}

main().catch(err => {
  console.error('Error:', err);
});
CódigojavascriptIntermedio

Consumo de Difusión RocketMQ

Implementar patrón de consumo de difusión donde todos los consumidores reciben el mismo mensaje

Dificultad

6/10

Tiempo estimado

20 min

Etiquetas

rocketmq, broadcast, fanout

Requisitos previos

RocketMQ server running, Node.js, RocketMQ basics

javascript
// RocketMQ Broadcast Consumption Example
// Demonstrates broadcasting messages to all consumers in a consumer group

const { Producer, Consumer, MessageModel } = require('apache-rocketmq');

// Configuration source producer
async function configurationProducer() {
  const producer = new Producer({
    endpoints: 'localhost:9876',
    producerGroup: 'config-producer-group',
    instanceName: 'config-producer',
  });

  await producer.start();
  console.log('Configuration producer started');

  // Configuration updates to broadcast
  const configUpdates = [
    {
      id: 'cfg001',
      type: 'feature_flag',
      key: 'new_dashboard_enabled',
      value: 'true',
      version: '1.0.0',
      description: 'Enable new dashboard UI for all users',
    },
    {
      id: 'cfg002',
      type: 'maintenance',
      key: 'system_maintenance',
      value: JSON.stringify({
        scheduled: '2025-12-15T02:00:00Z',
        duration: 2, // hours
        affectedServices: ['api', 'web', 'mobile'],
      }),
      version: '1.0.0',
      description: 'Scheduled system maintenance window',
    },
    {
      id: 'cfg003',
      type: 'rate_limit',
      key: 'api_rate_limit',
      value: '1000',
      version: '1.1.0',
      description: 'Update API rate limit to 1000 requests per minute',
    },
    {
      id: 'cfg004',
      type: 'security',
      key: 'password_policy',
      value: JSON.stringify({
        minLength: 8,
        requireUppercase: true,
        requireLowercase: true,
        requireNumbers: true,
        requireSpecialChars: true,
      }),
      version: '2.0.0',
      description: 'Enhanced password security requirements',
    },
    {
      id: 'cfg005',
      type: 'feature_flag',
      key: 'beta_features_enabled',
      value: 'false',
      version: '1.0.1',
      description: 'Disable beta features temporarily',
    },
  ];

  console.log('Broadcasting configuration updates...');

  for (const config of configUpdates) {
    const message = {
      topic: 'configuration-updates',
      tag: config.type,
      body: Buffer.from(JSON.stringify({
        ...config,
        timestamp: new Date().toISOString(),
        publisher: 'config-service',
      })),
      keys: [config.id, config.key],
      properties: {
        configId: config.id,
        configType: config.type,
        configVersion: config.version,
        priority: config.type === 'security' ? 'high' : 'normal',
      },
    };

    const result = await producer.send(message);
    console.log(`📡 Broadcast: ${config.type.padEnd(15)} ${config.key.padEnd(25)} -> v${config.version}`);
    console.log(`     ${config.description}`);
    console.log(`     Message ID: ${result.messageId}`);
    console.log('---');
  }

  await producer.shutdown();
  console.log('Configuration producer stopped');
}

// Service instance that receives configuration broadcasts
class ServiceInstance {
  constructor(name, instanceId) {
    this.name = name;
    this.instanceId = instanceId;
    this.config = new Map();
    this.startTime = new Date();
  }

  async startConsumer() {
    this.consumer = new Consumer({
      endpoints: 'localhost:9876',
      consumerGroup: 'config-consumer-group', // Same group for broadcast
      topic: 'configuration-updates',
      tag: '*',
      messageModel: MessageModel.BROADCASTING, // Key for broadcast consumption
      instanceName: `${this.name}-${this.instanceId}`,
    });

    await this.consumer.start();
    console.log(`[${this.name}-${this.instanceId}] Consumer started`);

    this.consumer.subscribe((msg, ack) => {
      this.handleConfigurationUpdate(msg, ack);
    });

    return this.consumer;
  }

  handleConfigurationUpdate(msg, ack) {
    try {
      const configUpdate = JSON.parse(msg.body.toString());
      const receivedTime = new Date();

      console.log(`\n📥 [${this.name}-${this.instanceId}] Configuration Update Received`);
      console.log(`    Config ID: ${configUpdate.id}`);
      console.log(`    Type: ${configUpdate.type}`);
      console.log(`    Key: ${configUpdate.key}`);
      console.log(`    New Value: ${configUpdate.value}`);
      console.log(`    Version: ${configUpdate.version}`);
      console.log(`    Description: ${configUpdate.description}`);
      console.log(`    Published: ${new Date(configUpdate.timestamp).toLocaleTimeString()}`);
      console.log(`    Received: ${receivedTime.toLocaleTimeString()}`);
      console.log(`    Latency: ${(receivedTime.getTime() - new Date(configUpdate.timestamp).getTime())}ms`);

      // Apply configuration update
      const previousValue = this.config.get(configUpdate.key);
      this.config.set(configUpdate.key, {
        value: configUpdate.value,
        version: configUpdate.version,
        updatedAt: configUpdate.timestamp,
        updatedAt: receivedTime.toISOString(),
      });

      console.log(`    Previous value: ${previousValue ? previousValue.value : 'NOT_SET'}`);
      console.log(`    Status: ${this.applyConfiguration(configUpdate)}`);

      // Show current configuration count
      console.log(`    Total configs: ${this.config.size}`);
      console.log('---');

      ack();
    } catch (err) {
      console.error(`[${this.name}-${this.instanceId}] Error handling config update:`, err);
      ack();
    }
  }

  applyConfiguration(configUpdate) {
    try {
      switch (configUpdate.type) {
        case 'feature_flag':
          const flagEnabled = configUpdate.value === 'true';
          console.log(`    → Feature flag '${configUpdate.key}' ${flagEnabled ? 'ENABLED' : 'DISABLED'}`);
          this.updateFeatureFlag(configUpdate.key, flagEnabled);
          break;

        case 'rate_limit':
          console.log(`    → Rate limit updated to ${configUpdate.value} requests/min`);
          this.updateRateLimit(parseInt(configUpdate.value));
          break;

        case 'security':
          console.log(`    → Security policy updated for '${configUpdate.key}'`);
          this.updateSecurityPolicy(configUpdate.key, JSON.parse(configUpdate.value));
          break;

        case 'maintenance':
          const maintenance = JSON.parse(configUpdate.value);
          console.log(`    → Maintenance scheduled: ${maintenance.scheduled}`);
          this.scheduleMaintenance(maintenance);
          break;

        default:
          console.log(`    → Generic configuration applied`);
      }

      return 'SUCCESS';
    } catch (err) {
      console.error(`    → Failed to apply configuration: ${err.message}`);
      return 'ERROR';
    }
  }

  // Simulate applying configurations
  updateFeatureFlag(key, enabled) {
    // In real service, this would toggle features
    console.log(`      [${this.name}] Feature '${key}' is now ${enabled ? 'ACTIVE' : 'INACTIVE'}`);
  }

  updateRateLimit(limit) {
    // In real service, this would update rate limiting
    console.log(`      [${this.name}] Rate limit set to ${limit}/min`);
  }

  updateSecurityPolicy(key, policy) {
    // In real service, this would update security policies
    console.log(`      [${this.name}] Security policy '${key}' updated`);
  }

  scheduleMaintenance(maintenance) {
    // In real service, this would prepare for maintenance
    console.log(`      [${this.name}] Preparing for maintenance window`);
  }

  async shutdown() {
    if (this.consumer) {
      await this.consumer.shutdown();
      console.log(`[${this.name}-${this.instanceId}] Consumer stopped`);
    }
  }

  printStatus() {
    console.log(`\n📊 [${this.name}-${this.instanceId}] Status:`);
    console.log(`    Uptime: ${Math.round((new Date() - this.startTime) / 1000)}s`);
    console.log(`    Configurations: ${this.config.size}`);

    if (this.config.size > 0) {
      console.log('    Active configs:');
      for (const [key, config] of this.config.entries()) {
        console.log(`      - ${key}: v${config.version}`);
      }
    }
  }
}

// Service health monitor
async function serviceHealthMonitor(services) {
  console.log('\n=== Service Health Monitor ===');

  const monitorInterval = setInterval(() => {
    console.log('\n' + '='.repeat(50));
    console.log(`Health Check - ${new Date().toLocaleTimeString()}`);
    console.log('='.repeat(50));

    services.forEach(service => {
      service.printStatus();
    });
  }, 8000);

  // Stop monitoring after 30 seconds
  setTimeout(() => {
    clearInterval(monitorInterval);
    console.log('\nHealth monitoring stopped');
  }, 30000);
}

// Demo cluster consumption vs broadcast consumption
async function demoConsumptionPatterns() {
  console.log('\n=== Consumption Patterns Demo ===');

  // Cluster consumer (load balancing)
  const clusterConsumer1 = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'cluster-consumer-group',
    topic: 'pattern-demo',
    tag: '*',
    messageModel: MessageModel.CLUSTERING,
    instanceName: 'cluster-consumer-1',
  });

  const clusterConsumer2 = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'cluster-consumer-group',
    topic: 'pattern-demo',
    tag: '*',
    messageModel: MessageModel.CLUSTERING,
    instanceName: 'cluster-consumer-2',
  });

  // Broadcast consumers (all get all messages)
  const broadcastConsumer1 = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'broadcast-consumer-group',
    topic: 'pattern-demo',
    tag: '*',
    messageModel: MessageModel.BROADCASTING,
    instanceName: 'broadcast-consumer-1',
  });

  const broadcastConsumer2 = new Consumer({
    endpoints: 'localhost:9876',
    consumerGroup: 'broadcast-consumer-group',
    topic: 'pattern-demo',
    tag: '*',
    messageModel: MessageModel.BROADCASTING,
    instanceName: 'broadcast-consumer-2',
  });

  await clusterConsumer1.start();
  await clusterConsumer2.start();
  await broadcastConsumer1.start();
  await broadcastConsumer2.start();

  // Set up message handlers
  let clusterMessageCount = 0;
  let broadcast1MessageCount = 0;
  let broadcast2MessageCount = 0;

  clusterConsumer1.subscribe((msg, ack) => {
    clusterMessageCount++;
    console.log(`[CLUSTER-1] Got message ${clusterMessageCount}: ${msg.body.toString()}`);
    ack();
  });

  clusterConsumer2.subscribe((msg, ack) => {
    console.log(`[CLUSTER-2] Got message: ${msg.body.toString()}`);
    ack();
  });

  broadcastConsumer1.subscribe((msg, ack) => {
    broadcast1MessageCount++;
    console.log(`[BROADCAST-1] Got message ${broadcast1MessageCount}: ${msg.body.toString()}`);
    ack();
  });

  broadcastConsumer2.subscribe((msg, ack) => {
    broadcast2MessageCount++;
    console.log(`[BROADCAST-2] Got message ${broadcast2MessageCount}: ${msg.body.toString()}`);
    ack();
  });

  // Producer for demo messages
  const producer = new Producer({
    endpoints: 'localhost:9876',
    producerGroup: 'pattern-demo-producer',
  });

  await producer.start();

  // Send messages
  for (let i = 1; i <= 5; i++) {
    await producer.send({
      topic: 'pattern-demo',
      body: Buffer.from(`Demo message ${i}`),
    });
    await new Promise(resolve => setTimeout(resolve, 500));
  }

  // Wait for processing
  await new Promise(resolve => setTimeout(resolve, 3000));

  console.log('\n📈 Consumption Pattern Results:');
  console.log(`Cluster consumers: ${clusterMessageCount} total messages (load balanced)`);
  console.log(`Broadcast consumer 1: ${broadcast1MessageCount} messages (all received)`);
  console.log(`Broadcast consumer 2: ${broadcast2MessageCount} messages (all received)`);

  // Cleanup
  await producer.shutdown();
  await clusterConsumer1.shutdown();
  await clusterConsumer2.shutdown();
  await broadcastConsumer1.shutdown();
  await broadcastConsumer2.shutdown();
}

// Main function
async function main() {
  console.log('=== RocketMQ Broadcast Consumption Example ===');

  try {
    // Step 1: Create multiple service instances
    console.log('\n1. Creating service instances...');
    const services = [
      new ServiceInstance('api-service', 'instance-1'),
      new ServiceInstance('api-service', 'instance-2'),
      new ServiceInstance('api-service', 'instance-3'),
      new ServiceInstance('web-service', 'instance-1'),
      new ServiceInstance('web-service', 'instance-2'),
    ];

    // Step 2: Start consumers for all services
    console.log('\n2. Starting broadcast consumers...');
    const consumerPromises = services.map(service => service.startConsumer());
    await Promise.all(consumerPromises);

    // Step 3: Wait for consumers to be ready
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Step 4: Start health monitor
    console.log('\n3. Starting service health monitor...');
    serviceHealthMonitor(services);

    // Step 5: Send configuration updates
    console.log('\n4. Broadcasting configuration updates...');
    await configurationProducer();

    // Step 6: Demo consumption patterns
    await new Promise(resolve => setTimeout(resolve, 3000));
    await demoConsumptionPatterns();

    // Step 7: Wait for all processing to complete
    console.log('\n5. Waiting for processing to complete...');
    await new Promise(resolve => setTimeout(resolve, 35000));

    // Step 8: Shutdown all services
    console.log('\n6. Shutting down all services...');
    const shutdownPromises = services.map(service => service.shutdown());
    await Promise.all(shutdownPromises);

    console.log('\nBroadcast consumption example completed!');
    console.log('\nKey Points:');
    console.log('- All instances in the same consumer group received every message');
    console.log('- Each service instance applied configurations independently');
    console.log('- Useful for configuration updates, cache invalidation, and notifications');
    console.log('- Contrast with clustering which load balances messages');
  } catch (err) {
    console.error('Error in broadcast consumption example:', err);
  }
}

main().catch(err => {
  console.error('Error:', err);
});

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Tema

Revisión e integración de un componente de sorteos autoalojado

Revisa la configuración, las respuestas de ejemplo, la legibilidad y el diseño adaptable antes de entregar los archivos y las pruebas de integración del sorteo.

Tema

Modelos farmacocineticos docentes y revision de resultados

Explora formulas farmacocineticas, supuestos de modelo y coherencia de resultados para docencia o QA, sin dar dosis ni consejo clinico.

Tema

Herramientas de cifrado clásico y moderno

Practica cifrados seguros para educación o CTF comparando transformaciones clásicas reversibles con cifrado moderno y sus límites de seguridad.

Tema

Revisión de una lección Markdown interactiva y entrega sin conexión

Revisa contenido y configuración, ensaya el HTML exportado sin conexión y separa archivos del público de fuentes privadas.

Inicio
Herramientas3212
Ejemplos593
Visualizaciones471
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web193

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Math & Numbers

Calculadora de sistemas de colas M/M/1

Calcula las métricas en régimen estacionario de la cola M/M/1: llegadas de Poisson (tasa λ), servicio exponencial (tasa μ), FCFS. Exige λ < μ; si no, el sistema es inestable y se rechaza la entrada. Reporta la utilización ρ, la probabilidad de sistema vacío P0, los esperados L (en sistema), Lq (en cola), los tiempos W y Wq, la probabilidad de esperar ρ y las probabilidades de estado P(n) = (1−ρ)ρⁿ (n = 0…5), con verificación cruzada por la ley de Little L = λW, Lq = λWq. Clásico: λ = 4/h, μ = 6/h → ρ = 0.6667, L = 2, Lq = 1.3333, W = 0.5, Wq = 0.3333.

Math & Numbers

Calculadora de colas M/M/c multiservidor

Calcula las métricas en régimen estacionario de la cola M/M/c (llegadas de Poisson a tasa λ, c servidores exponenciales idénticos de tasa μ, una cola FCFS compartida): reporta el tráfico ofrecido a = λ/μ, la utilización por servidor ρ, la probabilidad de sistema vacío P0, la probabilidad de espera Erlang-C Pw, los esperados Lq, L, W y Wq, con verificación cruzada por la ley de Little y la relación Pw→Lq. Exige λ < cμ (si no, se rechaza por inestable); con c = 1 las fórmulas colapsan en M/M/1. Clásico: λ = 6/h, μ = 3/h, c = 3 → P0 = 0.1111, Pw = 0.4444, Lq = 0.8889, L = 2.8889.

Mensajería

Ejemplos de NATS Message System

Ejemplos del sistema de mensajería NATS incluyendo pub/sub, request-reply, grupos de cola y JetStream para aplicaciones modernas cloud-native

Mensajería

Ejemplos de Apache Pulsar

Ejemplos de Apache Pulsar incluyendo pub/sub, lectores, consumidores con diferentes tipos de suscripción, gestión de esquemas y almacenamiento jerárquico para mensajería empresarial

Medios

Muestras de Audio DTS Sin Derechos

Muestras DTS con ambiente natural y música relajante para reproducción y conversión de audio