Como você produz e consome mensagens no RabbitMQ (uso básico)?

Question

Accepted Answer

O uso básico do RabbitMQ envolve **publicar** mensagens em um exchange/fila e **consumi-las** — tipicamente através de uma biblioteca cliente (usando o protocolo AMQP). Entender o fluxo básico de produção/consumo é o ponto de entrada prático.

## Produzindo (publicando) mensagens

```js
// connect, create a channel, declare a queue, publish
const channel = await connection.createChannel();
await channel.assertQueue('tasks', { durable: true });   // ensure the queue exists
channel.sendToQueue('tasks',
  Buffer.from(JSON.stringify({ task: 'send-email' })),
  { persistent: true }                                    // persistent message (survives restart)
);
// → publishes a message (here directly to a queue via the default exchange)
```

## Consumindo mensagens

```js
await channel.assertQueue('tasks', { durable: true });
channel.prefetch(1);   // process one at a time (fair dispatch)
channel.consume('tasks', (msg) => {
  const data = JSON.parse(msg.content.toString());
  // process the task...
  channel.ack(msg);     // ACKNOWLEDGE after processing (reliable)
}, { noAck: false });   // manual acks (reliable)
```

## Pontos práticos-chave

```text
✓ Use a CLIENT LIBRARY (amqplib for Node, pika for Python, Java client, etc.)
✓ CHANNELS → lightweight connections for operations (reuse the connection, use channels)
✓ DURABLE queues + PERSISTENT messages → survive broker restart (durability)
✓ MANUAL acks → reliable processing; PREFETCH → fair work distribution
✓ Handle errors, reconnection; use exchanges/bindings for routing (beyond the default exchange)
```

## Por que isso importa

Entender o uso básico de produção/consumo é valioso porque é o **ponto de entrada prático para usar RabbitMQ**, então é conhecimento prático necessário.

Saber como publicar e consumir mensagens é a habilidade fundamental para usar RabbitMQ em aplicações.

Entender **produzir mensagens** — conectar, criar um canal, declarar uma fila e publicar mensagens (com persistência para durabilidade) — é a operação básica de escrita.

Entender **consumir mensagens** — declarar a fila, definir prefetch, consumir mensagens, processá-las e **reconhecer** após o processamento (com acks manuais para confiabilidade) — é a operação básica de leitura que inclui as práticas importantes de confiabilidade.

Entender os **pontos práticos-chave** — usar uma biblioteca cliente (amqplib, pika, etc.), usar **canais** (conexões leves para operações, reutilizando a conexão), **filas duráveis mais mensagens persistentes** para sobreviver a reinicializações, **acks manuais** para processamento confiável e **prefetch** para distribuição justa de trabalho, e lidar com erros/reconexão e usar exchanges/bindings para roteamento — reflete as considerações práticas para uso real do RabbitMQ.

Estes pontos práticos (canais, durabilidade, acks manuais, prefetch) conectam o conhecimento conceitual (filas, reconhecimentos, durabilidade) ao código real e refletem a construção de aplicações RabbitMQ confiáveis.

Como produzir e consumir mensagens é a habilidade prática fundamental para usar RabbitMQ em aplicações, e como entender o fluxo básico e os pontos práticos (canais, durabilidade, acks manuais, prefetch) é conhecimento prático necessário, entender o uso básico de produção/consumo do RabbitMQ é conhecimento valioso e praticamente relevante — o ponto de entrada prático para usar RabbitMQ, conectando conceitos ao código (com as práticas de confiabilidade de filas duráveis, mensagens persistentes e acks manuais), e necessário para qualquer pessoa que realmente construa aplicações com RabbitMQ.