Gegendruck ist der ungesungene Held verteilter Systeme ,. , was hält Ihre Warteschlangen vor dem Platzen an den Nähten, wenn die Hersteller Feuerbotschaften schneller als Verbraucher können durch sie kauen .. , einfach setzen , : , es , ' , das System sagt , ," halten auf einen Moment , wenn Dinge zu beschäftigt werden , . ,

Hier ist das Ding. die Techniken in diesem Artikel gelten für praktisch jedes Message Queue und Service-Bus - —-RabbitMQ1-Kafka-,-Azure-Service Bus -,- AWS SQS-,- NATS-MSC5-Sie nennen es -MSC6- Die Besonderheiten variieren , aber die Grundsätze sind universell , .-I'-ll verwenden RabbitMQ für die meisten Beispiele, weil es , was ich am besten weiß ,,- aber I'-ll zeigen Ihnen, wie diese Muster über Plattformen übersetzen , .-

Ein Geständnis Selbst die meisten älteren Entwickler don-'.t implementieren richtige Gegendruckhandhabung... Sie bauen glückliche --Pfadsysteme, die in dev und Inszenierung gut funktionieren... dann fragen Sie sich, warum die Produktion während des Black Friday umfällt...... Backpressure Handling ist eine jener Techniken, die ".it Werke trennt....". von ".it Skalen... Wenn du nicht darüber nachdenkst.,.

Was Rückdruck ist

Im Kern ist der Gegendruck eine Rückkopplungsschleife, die Produzenten verlangsamt, wenn Verbraucher hinter dem . zurückbleiben Denken Sie daran wie Ampeln auf einer Schlupfstraße Sie können ' nicht nur auf die Autobahn stapeln, wann immer Sie Lust haben, . Die Lichter steuern den Fluss, MSC5 lassen Autos sicher verschmelzen, ohne einen Pfahl zu verursachen

Ohne Gegendruck wird ein schneller Produzent einen langsamen Verbraucher überwältigen... Nachrichten stapeln sich in Warteschlangen und der Speicher wird erschöpft.MSC3. Und schließlich fällt dein System über, ..

flowchart LR
    P[Producer] --> Q[Queue]
    Q --> C[Consumer]
    C -. "Slow down!" .-> P

    style P stroke:#f59e0b,stroke-width:2px
    style Q stroke:#0ea5e9,stroke-width:2px
    style C stroke:#10b981,stroke-width:2px

Die Schönheit des Rückdrucks ist, dass es ein Gespräch zwischen Produzent und Verbraucher Die Consumer-Signale ".I.'.m Full-,. geben Sie mir eine Minute, und der Hersteller reagiert auf ".Kein Problem, ,.I'.ll warten MS K8. Es ist höflich, ,. kollaborativ, und hält jeden davon ab zu fallen

Wie RabbitMQ mit dem Rückdruck fertig wird

KaninchenMQ ist ein offener message Broker, der die Erweitertes Message Queuing-ProtokollEs ist einer der am weitesten verbreiteten Nachrichten-Broker, die von Unternehmen von Startups bis zu Unternehmen wie Bloomberg, ,, Pivotal, , und VMware verwendet werden.

Was RabbitMQ übertrifft

• Komplexes Routing ,-Bindungen,- und Routing-Tasten lassen Sie anspruchsvolle Nachrichtenrouting Topologien erstellen.-Will Nachrichten zu mehreren Warteschlangen ausfächern?-Route basierend auf Headern?-Direkt an bestimmte Verbraucher?- RabbitMQ-'- Austauscharten (-Direkte ,-Fanout-,-Thema-Header-)- haben Sie abgedeckt
• Zuverlässigkeitsgarantien - Herausgeber bestätigt, VerbraucherbestätigungenL 347 vom 20.12.2013, S. 671. Persistente Nachrichten bedeuten, dass Sie Systeme bauen können, bei denen Nachrichtenverlust inakzeptabel ist.
• Flexibler Einsatz Starten Sie es auf einem einzigen Knoten für die Entwicklung, oder stellen Sie ein Cluster mit quorum Warteschlangen für hohe Verfügbarkeit in der Produktion
• Unterstützung durch das Protokoll Über die AMQP-Unterstützung hinaus unterstützt RabbitMQ MQTT ,(, IoT-),, STOMP Simple-Textprotokoll ), und hat ein Streams Funktion für Kafka---ähnliche Anhänge--nur Protokolle.-

Wann Alternativen in Betracht gezogen werden? Wenn Sie einen massiven Durchsatz mit einfacherem Routing benötigen, können Millionen von Nachrichten – / – second –), – Kafka – ' – log-- – basierende Architektur geeigneter sein.. – Wenn Sie auf einem Cloud-Anbieter alle - – ihre verwalteten Dienste – MSC8 – AWS SQS – MCSK11 – reduzieren Sie den Betriebsaufwand

RabbitMQ hat mehrere eingebaute Mechanismen für die Handhabung von Gegendruck-, und Verständnis sie ist entscheidend, wenn Sie Gebäudesysteme, die aufrecht unter Last bleiben müssen RabbitMQ Dokumentation ist exzellent.—-I'-ll Link zu bestimmten Seiten, wie wir gehen.

Durchflussregelung

Wenn RabbitMQ-'s Speichernutzung oder Warteschlangentiefe konfigurierte Schwellen überschreitet, aktiviert es DurchflussregelungDies blockiert vorübergehend Publisher-Verbindungen.— publishers can.MSC2 , senden neue Nachrichten, bis der Broker genug Backlog gelöscht hat. . , Siehe auch die Docs auf Erinnerungsalarme und Festplattenalarme welche die Durchflussregelung auslösen

flowchart TD
    subgraph "RabbitMQ Flow Control"
        A[Publisher Sends Message] --> B{Memory/Queue<br/>Threshold OK?}
        B -->|Yes| C[Message Accepted]
        C --> D[Add to Queue]
        B -->|No| E[Connection Blocked]
        E --> F[Publisher Waits]
        F --> G{Threshold<br/>Cleared?}
        G -->|No| F
        G -->|Yes| H[Connection Unblocked]
        H --> A
    end

    style E stroke:#ef4444,stroke-width:3px
    style H stroke:#10b981,stroke-width:2px

Die wichtigste Erkenntnis hier ist, dass RabbitMQ doesns-'-T einfach fallen Nachrichten, wenn unter Druck .— .it verlangsamt die Quelle Dies ist ein viel zivilisierter Ansatz als stillschweigend verwerfen Daten ?....

Danksagung des Verbrauchers

Verbraucher kontrollieren das Tempo durch Bestätigungen Eine Nachricht wird aus der Warteschlange entfernt, bis der Verbraucher sie explizit anerkennt...Wenn ein Verbraucher ACK-Nachrichten schnell genug sendet, wächst die Warteschlangen, die schließlich eine Strömungssteuerung nach vorn auslösen.

Sie können auch Präfetch Grenzen Um zu kontrollieren, wie viele unerkannte Nachrichten ein Verbraucher im Flug auf einmal haben kann, verhindert dies einen einzelnen langsamen Verbraucher vom Horten von Nachrichten.

// Set prefetch count to limit unacknowledged messages
channel.BasicQos(prefetchSize: 0, prefetchCount: 10, global: false);

Dies sagt RabbitMQ ,: , " , nur senden Sie mir Nachrichten zu einer Zeit , . , sobald ich einige ACK , , , können Sie mehr senden .." , es ist der Verbraucher ausdrücklich sagen, wie viel Druck kann es mit . , Dokumentation des Clients deckt die API im Detail ab

Wie andere Systeme mit Rückdruck umgehen

Die Muster sind universal, aber die Implementierungen unterscheiden sich von hier aus, wie einige andere beliebte Messaging-Systeme das gleiche Problem angehen.

Kafka, :, Verbraucher, kontrolliertes Polling

Apache Kafka ist eine verteilte Event-Streaming-Plattform, die für hohe --Durchsatz konzipiert wurde.,-Fehler --tolerante Messagings Im Gegensatz zu herkömmlichen Nachrichtenbrokern speichert Kafka Nachrichten in einem append---nur Protokoll und lässt Verbraucher ihre eigene Position verfolgen.MSC6-Offset).

Kafka nimmt einen grundlegend anderen Ansatz ein Ziehen Nachrichten anstatt sie geschoben zu haben . , Dies macht Rückdruck implizit , wenn ein Verbraucher tut , ' , es doesns , ' , nicht empfangen Nachrichten , . , der Broker doesnt ,' , t care ,; , er hält nur die Botschaften herum, bis der Verbraucher bereit ist , und sehen Sie die Kafka Verbraucherdokumentation für Details zum Wahlmodell

// Kafka consumer with explicit backpressure control
using var consumer = new ConsumerBuilder<string, string>(config).Build();
consumer.Subscribe("orders");

while (!cancellationToken.IsCancellationRequested)
{
    // Only fetch what you can handle - this IS your backpressure
    var result = consumer.Consume(timeout: TimeSpan.FromSeconds(1));

    if (result != null)
    {
        await ProcessMessageAsync(result.Message.Value);

        // Manual commit = explicit acknowledgement
        consumer.Commit(result);
    }

    // If processing is slow, you simply poll less frequently
    // Kafka doesn't push more messages at you
}

Die cleveren Bit-Bit-:-Kafka-'-Verbrauchergruppen automatisch wieder ausbalancieren Partitionen Wenn ein Verbraucher zurückfällt ,, können Sie mehr Konsumenten zu der Gruppe hinzufügen und Partitionen erhalten umverteilt .-Rückdruck wird eine Skalierung Entscheidung - .

// Control batch size to manage memory pressure
var config = new ConsumerConfig
{
    BootstrapServers = "localhost:9092",
    GroupId = "order-processors",
    AutoOffsetReset = AutoOffsetReset.Earliest,
    MaxPollIntervalMs = 300000,      // 5 mins max between polls
    MaxPartitionFetchBytes = 1048576, // 1MB max per partition fetch
    FetchMaxBytes = 52428800          // 50MB max total fetch
};

Azure-Service-Bus-:-Gleichzeitige Nachrichtensteuerung

Azure Service Bus ist ein vollständig verwalteter Enterprise-Meldungsbroker von Microsoft mit Warteschlangen und veröffentlicht-.Subscribe-Themen.. Es wurde entwickelt, um Anwendungen und Dienste in Cloud zu entkoppeln.-.native Architekturen...

Azure Service Bus verwendet ein MaxConcurrentCalls Einstellung, die schön einfach ist, wie viele Nachrichten Ihr Prozessor gleichzeitig verarbeitet, wird automatisch von . Das Dokumentation zur Nachrichtenverarbeitung deckt Performance-Tuning im Detail ab

var processor = client.CreateProcessor("orders-queue", new ServiceBusProcessorOptions
{
    // This IS your backpressure - only process 10 at a time
    MaxConcurrentCalls = 10,
    AutoCompleteMessages = false,
    PrefetchCount = 20  // Buffer 20 messages locally
});

processor.ProcessMessageAsync += async args =>
{
    try
    {
        await ProcessOrderAsync(args.Message.Body.ToString());
        await args.CompleteMessageAsync(args.Message);
    }
    catch (Exception ex)
    {
        // Abandon returns message to queue for retry
        await args.AbandonMessageAsync(args.Message);
    }
};

processor.ProcessErrorAsync += args =>
{
    Console.WriteLine($"Error: {args.Exception.Message}");
    return Task.CompletedTask;
};

await processor.StartProcessingAsync();

Azure Service Bus unterstützt auch Sitzungen für die bestellte Verarbeitung und Warteschlangen für toten - für Nachrichten, die wiederholt fehlschlagen.—- beides wichtig für das Managen von Druck, wenn Dinge schief gehen.

AWS SQS-:-Opsibility Timeout Tanz

Amazon Simple Queue-Service ist ein vollständig verwalteter Nachrichtenqueuing-Dienst von AWS-.-Sie bietet zwei Warteschlangentypen an.:-Standard. (-best.--effort ordering.MSSK4- at.MSC5-least.MS K6-once delivery.)- und FIFO-Bearbeitung.

Verwendung von SQS Sichtbarkeits-Timeouts als sein Rückdruckmechanismus, wenn du eine Nachricht empfangst, wird es für andere Verbraucher unsichtbar. Wenn du sie nicht in der Zeit löschst, erscheint es wieder für jemand anderes zu versuchen..

var sqsClient = new AmazonSQSClient();

// Receive with explicit backpressure control
var response = await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest
{
    QueueUrl = queueUrl,
    MaxNumberOfMessages = 10,           // Batch size = backpressure control
    WaitTimeSeconds = 20,               // Long polling
    VisibilityTimeout = 300             // 5 mins to process before retry
});

foreach (var message in response.Messages)
{
    try
    {
        await ProcessAsync(message.Body);

        // Only delete after successful processing
        await sqsClient.DeleteMessageAsync(queueUrl, message.ReceiptHandle);
    }
    catch
    {
        // Don't delete - message will become visible again after timeout
        // Optionally, change visibility timeout to retry sooner
        await sqsClient.ChangeMessageVisibilityAsync(queueUrl,
            message.ReceiptHandle, visibilityTimeout: 0);
    }
}

Die clevere SQS-Trick-Anwendung ApproximateNumberOfMessages zur Überwachung der Queue-Tieftiefe und Auto-Skala-Konsumenten

var attributes = await sqsClient.GetQueueAttributesAsync(new GetQueueAttributesRequest
{
    QueueUrl = queueUrl,
    AttributeNames = new List<string> { "ApproximateNumberOfMessages" }
});

var depth = int.Parse(attributes.Attributes["ApproximateNumberOfMessages"]);

if (depth > 1000)
{
    // Signal to scale up consumers
    await TriggerAutoScalingAsync();
}

NATS JetStream-:-Flow Control eingebaut

NATÜRE ist ein leichtgewichtiges, hochleistungsfähiges Messaging-System JetStream ist NATS-'s gebaut-in Persistenzschicht, die langlebige Streams hinzufügt, die exakt -einmal liefern,, und—,wichtig für unsexplizite Durchflussregelung.

NATS JetStream hat eine explizite Durchflusskontrolle mit Verbraucherbestätigungen und maximal anstehenden Message Limits.

var js = connection.CreateJetStreamContext();

var subscription = js.PushSubscribeAsync("orders.>", (sender, args) =>
{
    try
    {
        ProcessMessage(args.Message.Data);
        args.Message.Ack();
    }
    catch
    {
        args.Message.Nak();  // Negative ack - redeliver
    }
}, new PushSubscribeOptions.Builder()
    .WithConfiguration(new ConsumerConfiguration.Builder()
        .WithMaxAckPending(100)     // Max unacked messages - THIS is backpressure
        .WithAckWait(30000)         // 30 seconds to ack
        .Build())
    .Build());

Das gemeinsame Thema

Beachten Sie, was alle diese Systeme im gemeinsamen haben.

1. Explizite Batch-Grenzwerte für die Konkurrenz Du kontrollierst, wie viel du zu handhaben bereit bist
2. Danksagung – --basierter Fluss Nachrichten bleiben verfügbar, bis Sie die Verarbeitung bestätigen
3. Timeout---basierte Erholung Wenn Sie fehlschlagen, kehren die Nachrichten für den Wiederholungsversuch zurück.
4. Tiefenüberwachung Sie können immer fragen, ", wie gesichert bin I?"

Die Syntax unterscheidet sich von der Syntax, aber der Tanz ist derselbe. Sagen Sie mir, wann I'hve es behandelte..h Wenn ich nicht sage, dass 'h Ihnen in der Zeit sagen, ,h nehme an, ich habe versagt.

Code-Beispiele

Rechts - ,-let-'-s erhalten in den Code Hier sind praktische Beispiele für die Implementierung und Reaktion auf Gegendruck in Ihren Anwendungen

Überwachung der Queuetiefe

Erste Dinge zuerst ,— , können Sie verwalten, was Sie tun können , um zu messen , . Hier , wie man überprüft, wie viele Nachrichten in einem warten Warteschlange:

var queue = channel.QueueDeclare(
    queue: "tasks",
    durable: true,
    exclusive: false,
    autoDelete: false);

Console.WriteLine($"Messages ready: {queue.MessageCount}");

// React to queue depth
if (queue.MessageCount > 1000)
{
    Console.WriteLine("Queue backing up - consider throttling producers");
}

Dieses Snippet überprüft, wie viele Nachrichten warten .. , wenn die Zählung steigt ?, , dass . ' , das Ihr Stichwort zu Gaserzeuger oder skalieren Verbraucher .

Herausgeber bestätigt

Herausgeber bestätigt lassen Sie wissen, wenn RabbitMQ Ihre Nachricht erfolgreich empfangen und verarbeitet hat ... . Wenn die Bestätigungen verlangsamen ?, .

// Enable publisher confirms
channel.ConfirmSelect();

var body = Encoding.UTF8.GetBytes("Hello, Queue!");

channel.BasicPublish(
    exchange: "",
    routingKey: "tasks",
    basicProperties: null,
    body: body);

// Wait for confirmation - timeout indicates backpressure
bool confirmed = channel.WaitForConfirms(TimeSpan.FromSeconds(5));

if (!confirmed)
{
    Console.WriteLine("Message not confirmed - broker may be under pressure");
}

Wenn RabbitMQ kämpft, nehmen Sie die Bestätigungen länger oder gehen vollständig aus.Ihr Produzent kann dieses Signal verwenden, um sich zurückzuhalten und nicht auf mehr Druck zu stapeln.

Für High---Throughput-Szenarien, die asynchrone Bestätigungen von : wollen

channel.ConfirmSelect();

var outstandingConfirms = new ConcurrentDictionary<ulong, string>();

channel.BasicAcks += (sender, ea) =>
{
    if (ea.Multiple)
    {
        var confirmed = outstandingConfirms.Where(k => k.Key <= ea.DeliveryTag);
        foreach (var entry in confirmed)
        {
            outstandingConfirms.TryRemove(entry.Key, out _);
        }
    }
    else
    {
        outstandingConfirms.TryRemove(ea.DeliveryTag, out _);
    }
};

channel.BasicNacks += (sender, ea) =>
{
    // Message was rejected - implement retry logic
    Console.WriteLine($"Message {ea.DeliveryTag} was nacked - broker under pressure");
    // Back off before retrying
};

Retry mit exponentiellem Backoff

Wenn du den Gegendruck detektierst, ist die schlimmste Sache, die du tun kannst, sofort bei voller Geschwindigkeit erneut zu versuchen... Dass'.s wie Reaktion auf einen Stau durch Drücken des Beschleunigers härter.

public async Task PublishWithBackpressureAsync(
    IModel channel,
    byte[] body,
    int maxRetries = 5)
{
    int attempt = 0;

    while (attempt < maxRetries)
    {
        try
        {
            channel.ConfirmSelect();
            channel.BasicPublish(
                exchange: "",
                routingKey: "tasks",
                basicProperties: null,
                body: body);

            if (channel.WaitForConfirms(TimeSpan.FromSeconds(5)))
            {
                return; // Success
            }

            throw new Exception("Publish not confirmed");
        }
        catch (Exception ex)
        {
            attempt++;

            if (attempt >= maxRetries)
            {
                throw new Exception($"Failed to publish after {maxRetries} attempts", ex);
            }

            // Exponential backoff: 1s, 2s, 4s, 8s, 16s
            var delay = TimeSpan.FromSeconds(Math.Pow(2, attempt - 1));
            Console.WriteLine($"Backpressure detected - retry {attempt} after {delay}");

            await Task.Delay(delay);
        }
    }
}

Dies imitiert HTTP-'s .429 .( .Zu viele Anfragen . ) pattern .,. . Anstatt den Broker zu schlagen, halten wir vor dem erneuten Testen an die , .

Verwendung von Kanälen für den In---Prozess-Rückdruck

Wenn du eine interne Pipeline baust (Produzenten-Prozessoren-Konsumenten-Consumer alle innerhalb deiner Anwendung ),, .,NET' Channel<T> bietet elegante Unterstützung für den Gegendruck

// Create a bounded channel - backpressure is automatic
var channel = Channel.CreateBounded<WorkItem>(new BoundedChannelOptions(100)
{
    FullMode = BoundedChannelFullMode.Wait // Block producer when full
});

// Producer - will automatically wait when channel is full
async Task ProduceAsync(ChannelWriter<WorkItem> writer)
{
    for (int i = 0; i < 10000; i++)
    {
        var item = new WorkItem { Id = i };

        // This awaits if the channel is at capacity
        await writer.WriteAsync(item);

        Console.WriteLine($"Produced item {i}");
    }

    writer.Complete();
}

// Consumer - processes at its own pace
async Task ConsumeAsync(ChannelReader<WorkItem> reader)
{
    await foreach (var item in reader.ReadAllAsync())
    {
        // Simulate slow processing
        await Task.Delay(100);
        Console.WriteLine($"Processed item {item.Id}");
    }
}

// Run both concurrently
await Task.WhenAll(
    ProduceAsync(channel.Writer),
    ConsumeAsync(channel.Reader)
);

Der geschränkte Kanal wendet automatisch den Gegendruck an, wenn der Kanal voll ist.,. natürliche Verlangsamung, um dem Verbraucher gerecht zu werden.

Ein vollständiger Hinterdruck---Aware Publisher

Hier ist ein vollständigeres Beispiel, das die Überwachung zusammenbringt. Persistente Nachrichten um sicherzustellen, dass Nachrichten den Broker neu starten

public class BackpressureAwarePublisher : IDisposable
{
    private readonly IConnection _connection;
    private readonly IModel _channel;
    private readonly string _queueName;
    private readonly int _queueDepthThreshold;

    public BackpressureAwarePublisher(
        string hostName,
        string queueName,
        int queueDepthThreshold = 1000)
    {
        // See https://www.rabbitmq.com/docs/connections for connection best practices
        var factory = new ConnectionFactory { HostName = hostName };
        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel(); // Creates a channel - see https://www.rabbitmq.com/docs/channels
        _queueName = queueName;
        _queueDepthThreshold = queueDepthThreshold;

        _channel.QueueDeclare(
            queue: queueName,
            durable: true,
            exclusive: false,
            autoDelete: false);

        _channel.ConfirmSelect();
    }

    public async Task<bool> PublishAsync(byte[] body, CancellationToken ct = default)
    {
        // Check queue depth first
        var queueInfo = _channel.QueueDeclarePassive(_queueName);

        if (queueInfo.MessageCount > _queueDepthThreshold)
        {
            Console.WriteLine($"Queue depth {queueInfo.MessageCount} exceeds threshold - applying backpressure");

            // Wait for queue to drain a bit
            while (queueInfo.MessageCount > _queueDepthThreshold * 0.8)
            {
                await Task.Delay(1000, ct);
                queueInfo = _channel.QueueDeclarePassive(_queueName);
            }
        }

        // Publish with retry
        for (int attempt = 1; attempt <= 3; attempt++)
        {
            try
            {
                var properties = _channel.CreateBasicProperties();
                properties.Persistent = true;

                _channel.BasicPublish(
                    exchange: "",
                    routingKey: _queueName,
                    basicProperties: properties,
                    body: body);

                if (_channel.WaitForConfirms(TimeSpan.FromSeconds(5)))
                {
                    return true;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Publish attempt {attempt} failed: {ex.Message}");
            }

            if (attempt < 3)
            {
                await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)), ct);
            }
        }

        return false;
    }

    public void Dispose()
    {
        _channel?.Dispose();
        _connection?.Dispose();
    }
}

Best Practices

Für einen umfassenden Überblick über bausichere Systeme mit RabbitMQ-,, siehe den offiziellen Leitfaden für die Zuverlässigkeit.

Bleib ruhig.

Ein bisschen Tiefe ist normal und gesund..... bedeutet, dass Ihr System Last Spikes anmutig absorbiert....... das Ziel ist eine leere Warteschlange.... stabil Warteschlange, die nicht ungebunden wächst

Überwachung der Warteschlangentiefe im Laufe der Zeit - .- Suchen Sie nach Trends -,- Nicht Snapshots - MSC2- Eine Warteschlange, die konsequent bei ' - Nachrichten ist fein -MSC5- Eine Schlange, die von MSC6 gewachsen ist und während der letzten Stunde zu MSZ8 wuchs, braucht Aufmerksamkeit.

Pragmatisch sein

Apply patterns pragmatically-um-.- nicht jede Nachricht benötigt Publisher bestätigt: .-nicht jede Warteschlange braucht ausgefeilte Gegendruckhandhabung:.-Eine Warteschlangen, die Nachrichten pro Stunde verarbeitet, benötigt wahrscheinlich dieselbe Resilienz-Engineering wie eine Verarbeitung: 10,000-um pro Sekunde:.-um

Fragen Sie sich, wenn diese Nachricht verloren geht oder verzögert wird, wenn die Antwort nicht viel ist, ," Don-'-t over---engineer..-t Wenn die Antwort eine signifikante finanzielle oder Datenintegritätswirkung hat, investieren ,"-t in ordnungsgemäße Gegendruckbehandlung..-t

Smart skalieren

Wenn Warteschlangen aufwärts sichern, ist die Antwort: '.T immer mehr Produzenten hinzufügen..".That'.s wie versuchen, einen Stau zu beheben, indem Sie mehr Autos hinzufügen.

Berücksichtigen Sie:

• Verbraucher zuerst skalieren Sie können mehr Arbeiter hinzufügen, um den Backlog zu verarbeiten.
• Prüfung auf Engpässe Eine langsame Downstream-Abhängigkeit verursacht das Backup.
• Batch, wo möglich Die Verbraucher können mehrere Nachrichten gleichzeitig verarbeiten.

flowchart TD
    A[Queue Growing] --> B{Consumer<br/>Saturated?}
    B -->|Yes| C[Add Consumers]
    B -->|No| D{Downstream<br/>Bottleneck?}
    D -->|Yes| E[Fix/Scale Downstream]
    D -->|No| F{Can Batch<br/>Process?}
    F -->|Yes| G[Implement Batching]
    F -->|No| H[Accept Higher Latency<br/>or Reduce Load]

    style C stroke:#10b981,stroke-width:2px
    style E stroke:#f59e0b,stroke-width:2px
    style G stroke:#0ea5e9,stroke-width:2px

Überwachung und Warnung

Verwenden Sie die RabbitMQ Management Plugin oder HTTP API für eine umfassende Überwachung-.-Einrichtung von Alarmen für-MSC1-Einstellung

• Schwellenüberschreitung
• Zunahme der Verbraucherverzögerungen
• Publisher bestätigt das Timing
• Verbindung blockierte Ereignisse

Sie wollen etwas über Gegendruck wissen Vorher es wird eine Krise, nicht wenn dein System, das schon übergegangen ist,

Schlußfolgerung

Gegendruck ist gerade Rate begrenzend ,— .' ist eine Überlebenstaktik , durch die Behandlung es als ein Gespräch zwischen Produzent und Verbraucher , , , Sie bauen Systeme, die unter Druck widerstandsfähig bleiben ,

Die wichtigsten Erkenntnisse

1. Rückdruck ist Feedback Hersteller und Verbraucher arbeiten zusammen, um einen nachhaltigen Durchsatz zu finden
2. Überwachung der Warteschlangentiefe Sie können das, was Sie tun können, messen.
3. Publisher verwenden bestätigt Sie wissen, wann der Broker kämpft
4. Exponentielles Backoff umsetzen Ein System hämmert, das schon unter Druck ist
5. Verbraucher skalieren nicht nur Hersteller Befestigen Sie den Engpass nicht das Symptom

Wenn dein System sagt, dass 'm full-,um mir eine Minute geben, ist die richtige Antwort kein Problem, ,m I'um zu warten, was ."um die Essenz von gut -behaved verteilten Systemen, —, kollaborative und belastbare .

Bleiben Sie ruhig, wenn Warteschlangen wachsen ein Bit-, und erinnern Sie sich: : Ein System unter anmutigem Gegendruck ist unendlich besser als eine, die .' ist über vollständig gefallen .