# Переподключение

Order-svc имеет имя, пул и срок подключения. Но рестарт, развёртывание или потеря n1/n2/n3 разрывают уже работающий канал.

Клиент перебирает пул с задержками и возвращается. Публикации приложения накапливаются и отправляются после восстановления. Так серверный отказ не требует переписывать приложение.

Две идеи — backoff/jitter и буфер. Сначала RECONNECTING, затем распространение повторов на самый первый connect.

## Разрыв и RECONNECTING

**Разрыв** обнаруживается закрытием сокета или отсутствующим ответом keepalive. Клиент сообщает callback, но не закрывается: переходит из CONNECTED в **RECONNECTING**.

Он перебирает URL до успешного handshake, возвращается в CONNECTED и сообщает reconnect.

```
CONNECTED ──disconnect──▶ RECONNECTING ──PONG──▶ CONNECTED

                              │

                              └──pool exhausted, retries spent──▶ CLOSED
```

По умолчанию включено: Go AllowReconnect, Python allow\_reconnect, JavaScript reconnect; Java отключает noReconnect(). Rust/C# отдельного выключателя не имеют, только предел max\_reconnects/MaxReconnectRetry, стандартно неограниченный. Обычно оставляйте включённым.

## Повтор первого подключения

Обычная защита действует после хотя бы одного успеха. Большинство клиентов при первом недоступном пуле возвращают ошибку, не RECONNECTING. Эта обработка из [Подключения](/learn/resilient-clients/connecting.md) выявляет неверный адрес сразу; Python отличается.

Но после развёртывания приложение часто стартует раньше серверов и попадает в цикл падений. Можно включить повтор первого входа:

* Go RetryOnFailedConnect(true) сразу возвращает объект RECONNECTING; успех сообщает ConnectHandler, используются стандартные настройки повторов.
* JavaScript waitOnFirstConnect: true оставляет connect promise ожидающим; предел попыток действует после первого успеха.
* Python await nc.connect() уже перебирает до исчерпания каждого сервера; max\_reconnect\_attempts=-1 ждёт бесконечно, allow\_reconnect=False прекращает на первой ошибке.
* Java Nats.connectReconnectOnConnect(options) ждёт с повторами; Nats.connectAsynchronously(options, true) делает фоном через обязательный listener.
* Rust retry\_on\_initial\_connect() сразу возвращает клиент и подключает фоном вместо стандартной ошибки.
* C# RetryOnInitialConnect = true повторяет ConnectAsync или первую операцию до успеха либо отмены.

Тогда приложение ждёт серверы вместо перезапусков. CLI аналогичного флага не имеет и сразу отказывает.

## Backoff и jitter

После обхода пула без успеха клиент ждёт **backoff**. Go/Java/Python/JavaScript стандартно ждут одинаково каждый раз, рост задаётся callback. Rust/.NET увеличивают задержку сами.

База ReconnectWait обычно две секунды. **Jitter** — случайная добавка против синхронного наплыва клиентов: Go/Java/JavaScript до 100 мс открытого канала, до секунды TLS; C# до 100 мс всегда. Python и Rust случайности не добавляют: фиксированная reconnect\_time\_wait либо растущая задержка.

Go CustomReconnectDelay получает число полных обходов, Java reconnectDelayHandler — число попыток, JavaScript одноимённый callback без аргументов возвращает миллисекунды, Python reconnect\_to\_server\_handler — следующий сервер и ожидание. Go/JS не добавляют jitter поверх результата: включите сами. CLI использует бесконечные повторы, рост от 500 мс до 20 секунд и разброс 0,5–1,5 значения:

```
nats.MaxReconnects(-1),

nats.CustomReconnectDelay(func(attempts int) time.Duration {

    return backoff.Duration(attempts) // 500ms rising to a 20s cap, jitter included

}),
```

MaxReconnect ограничивает попытки до CLOSED. Go/Java/JS/Python учитывают по серверу и удаляют исчерпавшие; Go/Python сбрасывают после успеха. Стандарты: 60 у Go/Java/Python, 10 JS, бесконечно Rust/C#. Длительному order-svc задайте -1 там, где предел есть. Rust выражает бесконечность отсутствием max\_reconnects.

Настройка order-svc: бесконечно, две секунды базы, стандартный jitter.

#### CLI

```
#!/bin/bash



# Connect order-svc to the n1/n2/n3 server pool with reconnect tuned

# for a long-lived service, then publish one order.

#

# The CLI reconnects automatically and cannot script every client

# option (ReconnectWait, ReconnectJitter, a negative MaxReconnect for

# unlimited retries) the way the client libraries do. What it can show is

# the pool itself: pass the whole cluster as the server list so the

# client has somewhere to fail over to when one node goes away.

#

# --server takes a comma-separated pool. The client randomizes it by

# default and, on a disconnect, cycles the list with backoff + jitter

# until one node answers. --connection-name makes order-svc show up by

# name in `nats server report connections`.



# Publish a single order to orders.created against the pool. If the node

# the client first lands on goes away, the client reconnects to another

# member of the pool on its own and the publish rides through.

nats pub orders.created \

  '{"order_id":"ord_8w2k","customer":"acme-co","total_cents":4200,"ts":"2026-05-22T10:14:22Z"}' \

  --server "nats://n1:4222,nats://n2:4222,nats://n3:4222" \

  --connection-name order-svc
```

#### C

```
// Tune reconnect for a long-lived service: unlimited retries (a

// negative max), a two-second base wait between attempts on the same

// server, and jitter left at its default (up to 100ms, 1s over TLS)

// so a fleet of clients does not retry in lockstep.

if (s == NATS_OK)

    s = natsOptions_SetName(opts, "order-svc");

if (s == NATS_OK)

    s = natsOptions_SetMaxReconnect(opts, -1);

if (s == NATS_OK)

    s = natsOptions_SetReconnectWait(opts, 2000);



if (s == NATS_OK)

    s = natsConnection_Connect(&conn, opts);



// Publish one order against the pool. If the node the client landed

// on goes away, it reconnects to another member on its own.

if (s == NATS_OK)

    s = natsConnection_PublishString(conn, "orders.created",

            "{\"order_id\":\"ord_8w2k\",\"customer\":\"acme-co\","

            "\"total_cents\":4200,\"ts\":\"2026-05-22T10:14:22Z\"}");
```

Прежнее событие заказа:

```
{"order_id":"ord_8w2k","customer":"acme-co","total_cents":4200,"ts":"2026-05-22T10:14:22Z"}
```

Точные параметры — в API библиотеки, протокол и сервер — в [справочнике](/reference/.md).

## Наблюдение восстановления

Для проверки достаточно одного сервера: остановите и верните под работающим подписчиком.

Запустите:

```
nats-server
```

В другом терминале подпишитесь с trace:

```
nats sub "orders.>" --connection-name order-svc --trace
```

Ctrl-C и повторный запуск сервера дадут `>>> Disconnected due to: ..., will attempt reconnect`, затем `>>> Reconnected to ...`. Подписка восстановится автоматически без нового nats sub.

В пуле клиент вернётся на другой узел, пока первый выключен. Серверные причины и перенос нагрузки — [Топологии](/learn/topologies/.md).

## Буфер переподключения

Приложение продолжает публиковать во время разрыва. Что делать с ними?

**Буфер** хранит исходящие публикации RECONNECTING и отправляет по порядку после возврата. Go/Java стандартно 8 МБ — ReconnectBufSize/reconnectBufferSize, Python 2 МБ. Rust использует ограниченную очередь с обратным давлением.

Сначала восстанавливаются подписки, затем отправки. Это не гарантия доставки: Core остаётся не более одного раза, буфер не превращает запись в долговременную с ack.

При заполнении Go/Java/Python отклоняют следующую публикацию, Go — ErrReconnectBufExceeded. Rust ждёт свободного места. Ограничение защищает память; снижайте нагрузку.

Буфер не восстанавливает позицию потребителя JetStream: ею управляет [слой подтверждений](/learn/jetstream/acknowledgment.md), не соединение.

**Движение сообщений — Переподключение с задержкой (анимация):** Издатель теряет сервер и переподключается. Подключение к n1 отклоняется; клиент ждёт задержку и пробует следующий сервер пула, n2, который принимает соединение. Накопленные во время отключения сообщения сбрасываются в n2, а недействующая связь с n1 исчезает.

* n1 → n1 (тема: в соединении отказано)
* n1 → n1
* n1 → n2

## Типичные ошибки

Что нарушает восстановление:

**Конечный предел прекращает долгую аварию навсегда.** Go/Java/Python 60, JS 10. Для длительных сервисов -1 и наблюдение reconnect error. Rust/C# уже бесконечны.

Подключите журнал каждой попытки:

#### CLI

```
#!/bin/bash



# Keep retrying through a long outage and make every disconnect and

# reconnect visible.

#

# In a client library you set MaxReconnect to -1 (retry without limit) and

# register a reconnect-error callback that logs each failed attempt.

# The CLI has no callback to register. It always logs the disconnect;

# --trace also makes it log each reconnect delay and the reconnect

# itself, which is the observable half of the same behavior.

#

# To SEE it: run this against a single local nats-server, then stop and

# restart that server. The subscriber logs a disconnect, cycles its

# pool, and resumes — you never re-run the command. Pointed at the

# n1/n2/n3 pool, it rejoins on a surviving node instead.



# Start a local server in another terminal first:

#

#   nats-server

#

# Then subscribe across the pool. Leave it running, kill the server it

# is on, and watch it reconnect on its own.

nats sub "orders.>" \

  --server "nats://n1:4222,nats://n2:4222,nats://n3:4222" \

  --connection-name order-svc \

  --trace
```

#### C

```
// Retry without limit: a negative max means the client keeps cycling

// the pool through a long outage instead of moving to CLOSED.

if (s == NATS_OK)

    s = natsOptions_SetMaxReconnect(opts, -1);



// Make every drop and recovery visible. The C client reports the

// outage through the disconnected callback and the recovery through

// the reconnected one; the closed callback fires only if the

// connection ends for good, which unlimited retries prevent here.

if (s == NATS_OK)

    s = natsOptions_SetDisconnectedCB(opts, onDisconnected, NULL);

if (s == NATS_OK)

    s = natsOptions_SetReconnectedCB(opts, onReconnected, NULL);

if (s == NATS_OK)

    s = natsOptions_SetClosedCB(opts, onClosed, NULL);



if (s == NATS_OK)

    s = natsConnection_Connect(&conn, opts);



// Subscribe, then stop and restart the server underneath: the

// callbacks log the disconnect and the reconnect, and the

// subscription resumes on its own.

if (s == NATS_OK)

    s = natsConnection_Subscribe(&sub, conn, "orders.>", onMsg, NULL);
```

**[Повтор первого входа](#retrying-the-first-connect) скрывает неверный адрес.** Вечный RECONNECTING после развёртывания требует оповещения и журнала. В Go начальные неудачи тоже идут тому же обработчику.

**Нулевая задержка или отсутствие jitter перегружают пул.** Сохраняйте ненулевое ожидание и случайность против синхронного шторма.

**Полный буфер блокирует или отклоняет.** Не повторяйте publish тесным циклом. Снизьте входящий поток, дайте очереди опустеть после восстановления.

**Зависшая связь обнаруживается через минуты.** При PING раз в две минуты, допустимых двух без ответа отказ замечается на третьем — до шести минут. Rust раз в минуту — до трёх. Go отправляет PING независимо от входящего трафика и сбрасывает только PONG; Rust сдвигает интервал любым входящим сообщением. При необходимости уменьшите ping interval и MaxPingsOut, где доступен; Rust фиксирует два. Точные API — у библиотеки.

## Что уже готово

Order-svc и клиенты JetStream имеют:

* Обнаружение разрыва и RECONNECTING.
* Повтор первого входа при необходимости.
* Пул с задержками, jitter и неограниченными попытками.
* Автовосстановление подписок и отправку буфера.

События уже возникают; теперь объединим наблюдение и состояние для проверки здоровья.

## Что дальше

Все переходы и Closed в одном интерфейсе плюс опрос состояния.

Перейдите к [Событиям соединения](/learn/resilient-clients/connection-events.md).

## См. также

* [Топологии](/learn/topologies/.md) — серверный отказ.
* [JetStream → Подтверждения](/learn/jetstream/acknowledgment.md) — позиция.
* [Справочник](/reference/.md) — протокол; reconnect/keepalive в API клиента.
