CS Fundamentals Trainer · Guias

Filas de mensagens e garantias de entrega

At-most-once, at-least-once e exactly-once na prática: o transactional outbox, consumidores idempotentes, visibility timeouts e dead-letter queues, executados no PostgreSQL.

14 min de leitura

Uma fila de mensagens permite que uma parte de um sistema entregue trabalho a outra sem esperar por ela. O produtor coloca uma mensagem; um consumidor a retira depois. Esse desacoplamento dá suavização de picos de tráfego, retentativas e escalonamento independente, e cria um problema novo: redes e processos falham entre os passos, então uma mensagem pode se perder ou ser entregue duas vezes. Este guia cobre o que uma fila oferece, o que "exactly once" realmente significa e os padrões (outbox, consumidor idempotente, dead-letter queue) que tornam um sistema correto de qualquer forma. Os dois padrões principais foram executados de verdade no PostgreSQL, e os resultados são mostrados.

1. Por que usar uma fila

Diagram: A producer, a queue, and consumers working in parallel

Os custos: mais peças móveis, nenhum resultado imediato, mensagens às vezes fora de ordem, duplicatas e mais dificuldade para depurar um fluxo que atravessa serviços. Não adicione uma fila onde uma simples chamada de função ou uma tabela de banco de dados resolveriam.

2. Filas e logs

Dois designs compartilham a palavra "fila":

Fila de trabalho (SQS, RabbitMQ)Log (Kafka, Kinesis)
Uma mensagem éremovida depois de tratadamantida por um período de retenção; os consumidores acompanham a sua posição (offset)
Vários consumidores independentescada um precisa da própria filacada grupo de consumidores lê os mesmos dados
Reprocessar dados antigosnão (a menos que você os tenha guardado)sim, volte o offset
Ordenaçãoem geral no melhor esforço, ou por grupo de mensagens / fila FIFOordenada dentro de uma partição
Uso típicojobs em segundo planofluxos de eventos, pipelines de dados, event sourcing

Quanto à ordenação, um log dá ordem dentro de uma partição, e você escolhe a partição por uma chave (todos os eventos de um pedido vão para uma partição). Não há ordem total entre partições, então projete como se não houvesse nenhuma.

3. Garantias de entrega

O que acontece quando o consumidor ou a rede falham entre "recebi" e "terminei"? Há três contratos possíveis [1]:

A verdade incômoda: entre duas máquinas ligadas por uma rede não confiável, você não consegue tornar a entrega em si exactly-once, porque o remetente nunca sabe se uma confirmação perdida significa "não recebido" ou "recebido, ack perdido". O que os sistemas oferecem é processamento (ou efeito) exactly-once, construído com entrega at-least-once mais deduplicação, ou com uma transação que inclui tanto a leitura da mensagem quanto a escrita do seu resultado. O Kafka, por exemplo, oferece produtores idempotentes e transações que dão semântica exactly-once dentro do Kafka (ler-processar-escrever entre tópicos do Kafka) [1], mas, quando seu consumidor chama um sistema externo (um serviço de e-mail, uma API de pagamento), essa chamada volta a ser at-least-once, a menos que aquele sistema também ofereça idempotência.

Então a regra de trabalho é:

entrega at-least-once + um consumidor idempotente = efetivamente exactly once

4. O visibility timeout (como uma fila de trabalho trata uma queda)

Em uma fila como o SQS, quando um consumidor recebe uma mensagem, ela não é apagada: fica invisível para os outros consumidores durante o visibility timeout. Se o consumidor termina, ele apaga a mensagem. Se cai ou demora demais, o timeout expira, a mensagem volta a ficar visível e outro consumidor a recebe [2]. Isso dá entrega at-least-once. Consequências:

5. O problema da escrita dupla e o padrão outbox

Um bug muito comum: um serviço salva um pedido em seu banco de dados e publica um evento OrderPlaced.

BEGIN; INSERT INTO orders ...; COMMIT;     -- 1
publish("order.placed", ...)               -- 2   <- the process dies here: the order exists, no event

Troque a ordem, e uma queda gera um evento para um pedido que nunca foi salvo. Dois sistemas não podem ser atualizados atomicamente com uma escrita simples em cada um. A correção é o transactional outbox: grave o evento em uma tabela outbox na mesma transação de banco de dados que a linha de negócio e deixe um relay separado ler a tabela e publicar [3].

Diagram: Transactional outbox: the event is saved with the order, then relayed

Executei isto no PostgreSQL: três pedidos foram feitos, cada um com uma linha de outbox na mesma transação. A primeira execução do relay caiu depois de publicar, antes de marcar a linha como publicada (o pior momento). Ele reiniciou e rodou de novo. Resultado: o broker ficou com 4 mensagens para 3 ids distintos, uma duplicata, exatamente como o at-least-once prevê, e nenhum pedido se perdeu.

As tabelas e o relay que move linhas do outbox para o broker (Python com psycopg; publish representa o cliente do seu broker):

CREATE TABLE orders    (id serial PRIMARY KEY, item text);
CREATE TABLE outbox    (id bigserial PRIMARY KEY, topic text, payload jsonb, published_at timestamptz);
CREATE TABLE processed (message_id text PRIMARY KEY);
CREATE TABLE shipments (order_id int, item text);
def place_order(conn, item):
    with conn.transaction():                       # one transaction: order and event together
        oid = conn.execute("INSERT INTO orders (item) VALUES (%s) RETURNING id", (item,)).fetchone()[0]
        conn.execute("INSERT INTO outbox (topic, payload) VALUES ('order.placed', %s)",
                     (json.dumps({"order_id": oid, "item": item}),))
    return oid

def relay_once(conn, publish):
    with conn.transaction():                       # the row locks last until commit
        rows = conn.execute(
            "SELECT id, topic, payload FROM outbox WHERE published_at IS NULL "
            "ORDER BY id LIMIT 10 FOR UPDATE SKIP LOCKED").fetchall()
        for id_, topic, payload in rows:
            publish(f"outbox-{id_}", topic, payload)   # may repeat if we crash before the UPDATE
            conn.execute("UPDATE outbox SET published_at = now() WHERE id = %s", (id_,))

O select, a publicação e o update ficam em uma transação, então o lock obtido por FOR UPDATE é mantido até as linhas serem marcadas. Se o relay morre entre publish e o update, a transação sofre rollback, as linhas voltam a ficar não publicadas e a próxima execução as publica uma segunda vez: essa é a duplicata do experimento.

A consulta do relay, sozinha, reivindica linhas sem bloquear outros relays:

SELECT id, topic, payload
FROM outbox
WHERE published_at IS NULL
ORDER BY id
LIMIT 10
FOR UPDATE SKIP LOCKED;

FOR UPDATE SKIP LOCKED trava as linhas que estão sendo tratadas e faz as outras instâncias do relay as pularem em vez de esperar, de modo que vários relays podem rodar em paralelo sem pegar a mesma linha. (Linhas que foram puladas podem ser publicadas um pouco fora de ordem, então os consumidores não devem depender de ordenação estrita entre linhas.) Uma alternativa ao polling é a captura de dados de mudança (CDC): ler o próprio write-ahead log do banco e publicar a partir dele; ferramentas como o Debezium fazem isso [3].

6. O consumidor idempotente

Uma operação é idempotente se fazê-la duas vezes tem o mesmo efeito que fazê-la uma vez. "Definir o status como enviado" é idempotente; "somar 10 ao saldo" não é. Para o segundo tipo, torne-a idempotente lembrando quais mensagens você já tratou. Dê a cada mensagem um id único (o id da linha do outbox serve) e registre-o na mesma transação que o efeito:

BEGIN;
INSERT INTO processed (message_id) VALUES ($1) ON CONFLICT DO NOTHING RETURNING message_id;
-- if no row came back: it was a duplicate, ROLLBACK or just COMMIT and stop
INSERT INTO shipments (order_id, item) VALUES ($2, $3);
COMMIT;

Na minha execução, o consumidor tratou as quatro mensagens em ordem e devolveu: enviada; duplicata (ignorada); enviada; enviada. São 3 envios para 3 pedidos, apesar da duplicata. Como o id e o envio estão em uma transação, uma queda não pode deixar um sem o outro.

Aqui está o consumidor em código (escolha uma linguagem nas abas; sua escolha é lembrada):

def handle(conn, message_id, order_id, item):
    with conn.transaction():
        row = conn.execute(
            "INSERT INTO processed (message_id) VALUES (%s) "
            "ON CONFLICT DO NOTHING RETURNING message_id",
            (message_id,),
        ).fetchone()
        if row is None:
            return "duplicate"                         # already handled: do nothing
        conn.execute("INSERT INTO shipments (order_id, item) VALUES (%s, %s)", (order_id, item))
        return "shipped"
func handle(ctx context.Context, pool *pgxpool.Pool, messageID string, orderID int, item string) (string, error) {
	tx, err := pool.Begin(ctx)
	if err != nil {
		return "", err
	}
	defer tx.Rollback(ctx) // no-op after Commit

	tag, err := tx.Exec(ctx,
		`INSERT INTO processed (message_id) VALUES ($1) ON CONFLICT DO NOTHING`, messageID)
	if err != nil {
		return "", err
	}
	if tag.RowsAffected() == 0 {
		return "duplicate", nil
	}
	if _, err := tx.Exec(ctx,
		`INSERT INTO shipments (order_id, item) VALUES ($1, $2)`, orderID, item); err != nil {
		return "", err
	}
	return "shipped", tx.Commit(ctx)
}
// node-postgres; pool is a pg.Pool
async function handle(pool, messageId, orderId, item) {
  const client = await pool.connect();
  try {
    await client.query("BEGIN");
    const r = await client.query(
      "INSERT INTO processed (message_id) VALUES ($1) ON CONFLICT DO NOTHING",
      [messageId]
    );
    if (r.rowCount === 0) {
      await client.query("ROLLBACK");
      return "duplicate";
    }
    await client.query("INSERT INTO shipments (order_id, item) VALUES ($1, $2)", [orderId, item]);
    await client.query("COMMIT");
    return "shipped";
  } catch (e) {
    await client.query("ROLLBACK");
    throw e;
  } finally {
    client.release();
  }
}
// Npgsql
static async Task<string> Handle(NpgsqlDataSource db, string messageId, int orderId, string item)
{
    await using var conn = await db.OpenConnectionAsync();
    await using var tx = await conn.BeginTransactionAsync();

    await using var dedupe = new NpgsqlCommand(
        "INSERT INTO processed (message_id) VALUES (@m) ON CONFLICT DO NOTHING", conn, tx);
    dedupe.Parameters.AddWithValue("m", messageId);
    if (await dedupe.ExecuteNonQueryAsync() == 0)
    {
        await tx.RollbackAsync();
        return "duplicate";
    }

    await using var ship = new NpgsqlCommand(
        "INSERT INTO shipments (order_id, item) VALUES (@o, @i)", conn, tx);
    ship.Parameters.AddWithValue("o", orderId);
    ship.Parameters.AddWithValue("i", item);
    await ship.ExecuteNonQueryAsync();
    await tx.CommitAsync();
    return "shipped";
}

Quando o efeito é em um sistema externo (enviar um e-mail, cobrar um cartão), passe o id da mensagem como chave de idempotência se o sistema aceitar uma, para que a segunda chamada seja reconhecida como repetição. A tabela processed cresce para sempre, então apague os ids antigos depois de um período de retenção maior que a mais longa reentrega que você espera.

7. Falhas, mensagens venenosas e a dead-letter queue

Uma mensagem venenosa (poison message) é uma que sempre falha (dados inválidos, um bug). Sem um limite, ela é repetida para sempre e bloqueia a fila atrás dela (em uma fila ordenada) ou queima CPU. As defesas padrão:

8. Ordenação, backpressure e monitoramento

9. Perguntas que entrevistadores gostam de acrescentar

"Dá para ter entrega exactly-once?"

Não através de uma rede não confiável, como propriedade apenas da entrega. Você pode ter efeito exactly-once com entrega at-least-once mais tratamento idempotente, ou com transações que cobrem tanto o offset da mensagem quanto o resultado (como o Kafka faz dentro dos seus próprios tópicos).

"Por que não publicar simplesmente no broker dentro da transação do banco de dados?"

Uma transação de banco de dados não consegue desfazer uma mensagem já enviada a um broker, e o broker não pode fazer parte do commit do banco. Esse é o problema da escrita dupla; o outbox move o evento para dentro do banco para que um commit cubra os dois.

"Fila ou tabela de banco de dados para jobs?"

Uma tabela com FOR UPDATE SKIP LOCKED é uma fila perfeitamente boa em volume moderado e dá transações junto com seus dados de graça. Um broker é melhor para throughput muito alto, fan-out para muitos consumidores ou quando você quer um log reprocessável.

"Como você mantém a ordem com vários consumidores?"

Particione por uma chave, de modo que tudo de uma entidade vá a um consumidor por vez, e abra mão da ordem global.

"E se o consumidor for lento?"

Escale os consumidores (até o número de partições em um log), torne o trabalho mais barato, separe jobs lentos e rápidos em filas diferentes e use backpressure a montante.

10. Coisas a mencionar em uma entrevista

Resumo rápido

  1. Uma fila desacopla produtores e consumidores, absorve picos e permite retentativas.
  2. As redes falham entre os passos, então a entrega é at-most-once ou at-least-once; o "exactly once" é construído por cima.
  3. Confirme depois de processar e espere duplicatas.
  4. Use o outbox para que uma mudança de estado e o seu evento sejam salvos atomicamente.
  5. Torne os consumidores idempotentes: registre o id da mensagem na mesma transação que o efeito.
  6. Limite as retentativas, use backoff e envie mensagens venenosas para uma dead-letter queue.
  7. Observe a profundidade da fila e a idade da mensagem mais antiga.

Fontes

  1. Confluent, Kafka design: delivery semantics. At most once, at least once, exactly once; produtores idempotentes e transações.
  2. AWS, Amazon SQS visibility timeout.
  3. Chris Richardson, Pattern: Transactional outbox e Pattern: Transaction log tailing.
  4. Documentação do PostgreSQL, The Locking Clause: FOR UPDATE ... SKIP LOCKED.
  5. Documentação do PostgreSQL, INSERT ... ON CONFLICT.
  6. Debezium, Outbox event router.
  7. Martin Kleppmann, Designing Data-Intensive Applications, O'Reilly, 2017, capítulo 11 (processamento de fluxos) e capítulo 9 (consistência e consenso).

Pratique este tema: System Design System Design › Distributed systems

Mais guias