docs(HISTORY): section 38 — remove names

The platform (185.247.187.147) terminates TLS externally before nginx.
HTTP-01 ACME challenge was stuck for 8 days because the platform
globally redirects HTTP→HTTPS before reaching nginx ingress.

Changes:
- Remove cert-manager.io/cluster-issuer: letsencrypt-prod annotation
- Remove tls section (iot-kube5s-ru-tls secret was never created)
- Set ssl-redirect: false (TLS termination is at the edge, not nginx)
- Update comment to document the actual TLS architecture

.github/copilot-instructions.md

@@ -1,175 +1,10 @@
-# Правила работы агента в проекте IoT
+# Правила
 
-## ГЛАВНОЕ ПРАВИЛО
+> Подробные правила: [`.github/pravila.md`](pravila.md)
 
-**НЕ "СОВЕРШЕНСТВОВАТЬ" РАБОЧИЙ КОД БЕЗ ЯВНОГО УКАЗАНИЯ.**
+1. Не трогать рабочий код без явного указания.
-
+2. Файлы редактировать локально — `~/remote_dev/` = `~/terra/` на ВМ (sshfs), SCP не нужен.
----
+3. Все команды — **только через SSH**, никогда локально:
-
+   ```bash
-## ЗАПРЕТ НА ВЫДУМКИ
+   ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10 naeel@5.172.178.213 'КОМАНДА'
-
+   ```
-**КАТЕГОРИЧЕСКИ ЗАПРЕЩАЕТСЯ придумывать, догадываться или предполагать:**
-- значения параметров, которые не видны в коде или документации
-- допустимые значения enum/ролей/типов — если не взяты из реального источника
-- поведение API, провайдеров, библиотек — если не подтверждено кодом или документацией
-- любые факты о системе, которые агент "знает" из общих соображений
-
-**Если информации нет — спросить у пользователя. Не угадывать.**
-
-Если код работает — не трогать. Никаких:
-- рефакторингов "попутно"
-- улучшений стиля
-- добавления комментариев / docstring
-- переименований переменных
-- "пока уж заодно поправлю"
-
-Делай только то, о чём явно попросили. Ничего лишнего.
-
----
-
-## ⚠️ ВЫПОЛНЕНИЕ КОМАНД — ТОЛЬКО НА УДАЛЁННОЙ МАШИНЕ
-
-- Все команды (git, go, docker, kubectl, make и т.д.) выполнять **ТОЛЬКО на удалённой машине** через SSH.
-- **На локальной машине команды не запускать вообще.**
-- Если для задачи необходимо выполнить что-то локально — **спросить явное разрешение у пользователя** перед запуском.
-
-### Параметры удалённой машины
-
-| Параметр | Значение |
-|---|---|
-| Хост | `5.172.178.213` |
-| Пользователь | `naeel` |
-| SSH-ключ | `~/.ssh/id_ed25519` |
-| Рабочий каталог | `/home/naeel/terra/IoT` |
-
-### Шаблон команды
-
-```bash
-ssh -i ~/.ssh/id_ed25519 \
-    -o StrictHostKeyChecking=no \
-    -o ConnectTimeout=10 \
-    naeel@5.172.178.213 \
-    'cd /home/naeel/terra/IoT && <КОМАНДА>'
-```
-
-### Примеры
-
-```bash
-# git статус
-ssh -i ~/.ssh/id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10 naeel@5.172.178.213 \
-  'cd /home/naeel/terra/IoT && git status'
-
-# commit + push
-ssh -i ~/.ssh/id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10 naeel@5.172.178.213 \
-  'cd /home/naeel/terra/IoT && git add -A && git commit -m "..." && git push'
-
-# сборка go
-ssh -i ~/.ssh/id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10 naeel@5.172.178.213 \
-  'cd /home/naeel/terra/IoT && go build ./...'
-```
-
-### Git / Gitea
-
-- Remote: `https://gitea.services.ngcloud.ru/Nail/IoT.git` (HTTPS)
-- SSH до Gitea **недоступен** с удалённой машины — использовать только HTTPS.
-- Credentials сохранены на удалённой машине в `~/.git-credentials`.
-
----
-
-## О проекте
-
-IoT managed service — отдельная репа, вынесенная из sless.
-Go модуль: `gitea.services.ngcloud.ru/Nail/IoT`
-Репа: https://gitea.services.ngcloud.ru/Nail/IoT
-
-### Компоненты (3 бинарника из одного образа):
-1. **iot-operator** (`cmd/iot-operator/`) — controller-manager (IoTDevice CRD) + REST API на :9090
-2. **mqtt-bridge** (`cmd/mqtt-bridge/`) — MQTT (EMQX) → Kafka bridge
-3. **kafka-consumer** (`cmd/kafka-consumer/`) — Kafka → Postgres pipeline
-
-### Стек:
-- Go 1.25, controller-runtime v0.14, gorilla/mux
-- CRD: `iot.kube5s.ru/v1alpha1` (IoTDevice)
-- EMQX — MQTT брокер, Kafka — очередь телеметрии
-- PostgreSQL — per-tenant databases для телеметрии
-- Docker Hub: `naeel/iot-operator`
-
-### Структура:
-```
-cmd/iot-operator/    — точка входа (controller + API сервер)
-cmd/mqtt-bridge/     — MQTT→Kafka bridge
-cmd/kafka-consumer/  — Kafka→Postgres
-api/v1alpha1/        — CRD Go types (IoTDevice)
-controllers/         — IoTDevice reconciler
-internal/api/        — REST handlers, router, middleware, UI (go:embed)
-internal/storage/    — iotpg (per-tenant Postgres)
-config/crd/          — CRD YAML manifests
-deployments/k8s/     — k8s deployment YAMLs
-doc/                 — документация
-examples/            — примеры (Terraform, handler.py)
-```
-
----
-
-## Комментарии в коде
-
-Комментарии — обязательны:
-- В начале каждого файла при создании или правке — дата и время изменения
-- На каждой функции/методе — краткое назначение
-- На нетривиальной логике — **почему** сделано именно так (не "что делает", а "зачем")
-
-Цель: любой агент в новом чате должен понять логику без дополнительных вопросов.
-
----
-
-## Темп работы
-
-Не спешить. Перед каждым шагом — убедиться что предыдущий понят и согласован.
-
----
-
-## Документация
-
-Всё важное фиксировать в `doc/`:
-- `doc/architecture/` — архитектура, стек, схемы
-- `doc/api/` — дизайн API
-- `doc/decisions/` — принятые решения с обоснованием
-- `doc/infrastructure/` — инфраструктура, кластер, сервисы
-- `doc/errors/` — ошибки и как решили
-- `doc/progress.md` — трекер задач
-
-Обновлять после каждого значимого изменения.
-
----
-
-## Именование
-
-Имена должны быть **уникальными и осмысленными по всему проекту**:
-- имена файлов
-- имена функций/методов
-- имена переменных/констант
-- имена ресурсов (Terraform, Kubernetes и т.д.)
-
-Цель: чтобы поиск по проекту находил нужные сущности без неоднозначности, а имя сразу отражало назначение.
-
-Запрещены безликие и повторяющиеся имена вида `handler.py`, `handle`, `data`, `value`, `temp` без контекста.
-
----
-
-## Лог мышления (обязательно)
-
-Каждый агент в каждом чате **обязан** вести лог своих рассуждений:
-- Папка: `doc/thinking/`
-- Файл: `ГГГГ-ММ-ДД.md` (по дате сессии)
-- В начале файла указать имя агента и модель
-- Если файл на текущую дату уже существует — дописывать в конец, добавив разделитель `---` и имя агента
-- Записывать **полный** ход мыслей: что анализирую, какие гипотезы, что нашёл, что отбросил, к чему пришёл, почему
-- Записывать **до** начала действий (план) и **после** (результат)
-
-Цель: пользователь должен видеть весь процесс рассуждений в читаемом виде.
-
----
-
-## Git
-
-Коммитить и пушить после каждого завершённого этапа.

.github/pravila.md

@@ -1,35 +1,23 @@
 # Правила работы агента
 
-## ⛔⛔⛔ DOCKER — ОБЯЗАТЕЛЬНЫЙ ПОРЯДОК ПЕРЕД КАЖДЫМ BUILD
+## Файловая система
 
-1. УВЕЛИЧИТЬ ТЕГ в `deployments/k8s/iot-console.yaml` (vX.Y.Z → vX.Y.Z+1)
+`~/remote_dev/` (локально) примонтирован через sshfs к `~/terra/` на ВМ — **одна ФС**.
-2. rsync на ВМ
+Файлы, сохранённые локально, мгновенно видны на ВМ. SCP не нужен.
-3. ПРОВЕРИТЬ что файлы на ВМ новые (grep ключевой строки)
-4. docker build с НОВЫМ тегом
-5. docker push с НОВЫМ тегом
-6. kubectl apply (не rollout restart — apply подтягивает новый тег)
 
-**НИКОГДА не делать `docker build` со старым тегом — под не перетянет образ (imagePullPolicy: IfNotPresent)**
+Монтирование может слетать. Признак: файлы рассинхронизированы.
 
-## Файловая система (актуально)
+```bash
+# Размонтировать
+fusermount -u ~/remote_dev
+# Если завис: sudo umount -l /home/naeel/remote_dev
 
-1. Все файлы редактируются локально: `~/IoT`
+# Примонтировать
-2. После любых изменений — обязательно rsync на ВМ:
+sshfs naeel@5.172.178.213:/home/naeel/terra ~/remote_dev \
-   rsync -az \
+  -o cache=no -o no_readahead -o reconnect \
-     -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
+  -o ServerAliveInterval=15 -o ServerAliveCountMax=3 \
-     ~/IoT/ \
+  -o IdentityFile=~/.ssh/naeel_vm_id_ed25519
-     naeel@5.172.178.213:~/terra/IoT/
+```
-
-3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/IoT
-4. Docker, kubectl и другие инфраструктурные команды — только через SSH на ВМ
-5. Перед запуском любой команды на ВМ обязательно убедиться, что синхронизация (rsync) выполнена
-6. SCP, sshfs, remote_dev и маунты больше НЕ используются
-7. Только rsync для синхронизации
-
-Пример:
-1. Редактируешь локально
-2. rsync на ВМ
-3. Выполняешь команды через SSH на ВМ
 
 ## SSH
 
@@ -49,11 +37,7 @@ ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=
 
 ## Git
 
-⛔⛔⛔ АБСОЛЮТНОЕ ПРАВИЛО:
+Коммитить и пушить через SSH после каждого завершённого этапа.
-- Git — ТОЛЬКО ЛОКАЛЬНО в `~/IoT`. НИКОГДА через SSH на VM.
-- Разрешены ТОЛЬКО две операции: `git commit` и `git push`.
-- ЗАПРЕЩЕНО: git pull, git fetch, git rebase, git merge, git reset, git stash, git checkout — что угодно кроме commit и push.
-- Если push отклонён — СТОП, доложить пользователю. Не лезть в pull/merge/rebase самостоятельно.
 
 Версионирование тегами: `vMAJOR.MINOR.PATCH`
 - Patch — любое изменение кода
@@ -64,36 +48,9 @@ ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=
 git tag vX.Y.Z && git push origin vX.Y.Z
 ```
 
-## ⛔ ТЕРМИНАЛЬНЫЙ БУФЕР — НИКОГДА НЕ ЧИТАТЬ СТАРЫЙ
+## Поведение агента
 
-**АБСОЛЮТНОЕ ПРАВИЛО:**
+- Не трогать рабочий код без явного указания
-- get_terminal_output из старых сессий — МУСОР. Там старые прогоны.
+- Не делать ничего сверх того, о чём явно попросили
-- Всегда запускать новую команду через SSH и читать её вывод напрямую.
+- Деструктивные операции (`kubectl delete`, `rm -rf`, `terraform destroy` и др.) — только после явного подтверждения с указанием конкретных объектов
-- НИКОГДА не читать буфер терминала из предыдущей сессии как актуальные данные.
+- Отвечать кратко, без вступлений, извинений, благодарностей и прочей воды
-- Актуальный результат — только из команды, которая была запущена СЕЙЧАС.
-
-## ⛔ ДОКУМЕНТАЦИЯ ТЕСТ-ПРОГОН�ОВ — В РЕАЛЬНОМ ВРЕМЕНИ
-
-**Правила:**
-1. Перед запуском `run_all.sh` — создать файл `test-results/YYYY-MM-DD_HH-MM.log` и записать в него метку времени и что запускается.
-2. Запускать `run_all.sh 2>&1 | tee ~/terra/IoT/test-results/YYYY-MM-DD_HH-MM.log` — вывод пишется сразу в файл и отображается в терминале.
-3. После завершения — rsync лога локально. Лог остаётся как документация.
-4. Папка `test-results/` в репозитории — `.gitignore` не добавлять, логи коммитить.
-
-**Формат запуска:**
-```bash
-LOG="test-results/$(date +%Y-%m-%d_%H-%M).log"
-ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no naeel@5.172.178.213 \
-  "bash ~/terra/IoT/scripts/run_all.sh 2>&1 | tee ~/terra/IoT/${LOG}"
-rsync -az -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no" \
-  naeel@5.172.178.213:~/terra/IoT/test-results/ ~/IoT/test-results/
-```
-
-**Никогда не разбираться с результатами по памяти / буферу / чату. Только лог.**
-
-## ⛔ РУЧНЫЕ ПАТЧИ — ЗАПРЕЩЕНЫ
-
-- НИКОГДА не применять ручные патчи (`kubectl patch`, `kubectl apply` отдельных полей, `python -c` замены в yaml и т.д.) без явного указания.
-- Все изменения — только через код (Helm chart, YAML, Go-код) + сборка + деплой.
-- Ручной патч слетает при следующем helm upgrade/redeploy → регрессия.
-- Исключение: только если пользователь явно написал "примени ручной патч".

.gitignore

@@ -1,13 +1,40 @@
-# Бинарники
+# Бинарники (только в корне проекта, не директории cmd/)
-iot-operator
+/iot-operator
-mqtt-bridge
+/mqtt-bridge
-kafka-consumer
+/kafka-consumer
+/sqs-consumer
 bin/
+ws-probe/ws-probe
+/iot-service
 
 # Go
 *.exe
 *.test
 *.out
+*.prof
+*.cover
+
+# Python — кэш и генерируемые файлы
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.tox/
+.venv/
+venv/
+htmlcov/
+.coverage
+.coverage.*
+*.egg-info/
+build/
+dist/
+.eggs/
+
+# Логи
+*.log
+logs/
 
 # IDE
 .idea/
@@ -19,3 +46,11 @@ bin/
 # OS
 .DS_Store
 Thumbs.db
+
+# Прочие генерируемые/временные
+*.tmp
+*.temp
+*.bak
+*.orig
+*.swp
+.DS_Store

Dockerfile

@@ -1,39 +1,38 @@
-# Создано: 2026-04-12
+# Dockerfile — монолит iot-service (один бинарник, один контейнер).
-# Dockerfile для IoT managed service.
+# Образ: naeel/iot-service (Docker Hub, публичный — требование платформы).
-# Multi-stage build: 3 бинарника (iot-operator, mqtt-bridge, kafka-consumer).
+#
-# Образ: naeel/iot-operator (Docker Hub).
+# Env-дефолты (не секреты) вшиты сюда — deck-UI задаёт только секреты.
 
 FROM golang:1.25 AS builder
 WORKDIR /workspace
 
-# Кэширование зависимостей
 COPY go.mod go.sum ./
 RUN go mod download
 
-# Исходный код
-COPY api/ api/
-COPY controllers/ controllers/
 COPY cmd/ cmd/
 COPY internal/ internal/
 
-# iot-operator — controller-manager + REST API
+ARG VERSION=dev
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o iot-operator ./cmd/iot-operator/
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a \
+    -ldflags "-X main.version=${VERSION}" -o iot-service ./cmd/iot-service/
 
-# mqtt-bridge — MQTT (EMQX) → Kafka
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o mqtt-bridge ./cmd/mqtt-bridge/
-
-# kafka-consumer — Kafka → Postgres
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o kafka-consumer ./cmd/kafka-consumer/
-
-# --- Runtime ---
 FROM gcr.io/distroless/static:nonroot
 WORKDIR /
-
+COPY --from=builder /workspace/iot-service .
-# Все три бинарника в одном образе.
-# Какой запускать — определяется command в k8s Deployment.
-COPY --from=builder /workspace/iot-operator .
-COPY --from=builder /workspace/mqtt-bridge .
-COPY --from=builder /workspace/kafka-consumer .
 
 USER 65532:65532
-ENTRYPOINT ["/iot-operator"]
+EXPOSE 9090
+
+ENV API_PORT=9090 \
+    SQS_ENDPOINT=http://containerk8s.f1ffb134-7d16-45bd-8bef-69f6ec8ab33c.svc.cluster.local:4100 \
+    SQS_QUEUE_NAME=iot-telemetry \
+    SQS_REGION=us-east-1 \
+    SQS_LONG_POLL_SECONDS=20 \
+    SQS_VISIBILITY_TIMEOUT=120 \
+    MQTT_CLIENT_ID=iot-bridge \
+    MQTT_PORT=8083 \
+    MQTT_WS_PATH=/mqtt \
+    AUTH_TEST_MODE=false \
+    LOG_LEVEL=info
+
+ENTRYPOINT ["/iot-service"]

LEGACY.md

@@ -0,0 +1,47 @@
+# ⛔⛔⛔ ЛЕГАСИ — СТАРЫЙ IoT (k8s-деплой)
+
+С 2026-08-16 всё, что относится к СТАРОМУ IoT (деплой в собственном k8s,
+оператор, CRD), — **ЛЕГАСИ**. **НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ** при принятии решений.
+Не использовать, не ссылаться, не переносить в новую архитектуру без отдельной
+команды.
+
+**Актуальное:**
+- `HISTORY/2026-08-16-session-log.md` — состояние, диагностика, план миграции
+- `doc/sqs-integration.md` — актуальная интеграция с shared-sqs
+
+## Помечено ЛЕГАСИ и перенесено в `legacy/` (2026-08-16)
+
+- `legacy/deployments/` — все k8s-манифесты старого деплоя
+- `legacy/config/` — CRD IoTDevice
+- `legacy/doc/` — все старые документы (deployment, architecture, api, decisions,
+  thinking, progress, testing и др.)
+- `legacy/examples/` — старые примеры (RabbitMQ/serverless)
+- `legacy/2026-08-13-migration-to-managed.md` — СТАРЫЙ план миграции (Node.js) — ОТМЕНЁН
+- `legacy/Dockerfile.old` — собирал 3 старых бинарника
+- `legacy/Makefile.old` — старые k8s-цели
+- `cmd/iot-operator/`, `controllers/`, `api/v1alpha1/` — оператор (CRD-контроллер);
+  пока в корне из-за импортов (перенос — во время Фазы 1 после переписывания хендлеров)
+
+## Аудит вмешательства старого IoT (2026-08-16, проверено)
+
+- **Код:** k8s-зависимости есть ТОЛЬКО в `internal/api/handler/` (handler.go,
+  iot_device_handler.go, iot_admin_stats_handler.go — controller-runtime,
+  corev1, CRD-типы). Всё остальное чисто: router, middleware, UI-embeds,
+  `internal/storage/iotpg/`, `cmd/mqtt-bridge/`, `cmd/sqs-consumer/`.
+- **Правило для монолита:** новый код НЕ импортирует `controllers/`,
+  `api/v1alpha1/`, k8s-клиент. Хендлеры устройств переписываются на
+  PG-хранилище (`iot_devices`); после этого k8s-депы удаляются из go.mod.
+- **Данные:** старый shared-sqs (qu.kube5s.ru) удалён полностью — старых
+  очередей нет. В managed PG остались старые тестовые tenant-DB (изолированы,
+  на новый код не влияют; очистка — только по отдельной команде).
+  Старые k8s Secrets не читаются (новый код без k8s-клиента).
+- **Артефакты:** `bin/` в git не отслеживается; CI (.github/) содержит только
+  правила — старых пайплайнов нет.
+
+## НЕ легаси (актуально)
+
+- `HISTORY/2026-08-16-session-log.md`
+- `doc/sqs-integration.md`
+- `ws-probe/`
+- `cmd/mqtt-bridge/`, `cmd/sqs-consumer/`, `internal/` — Go-код, переиспользуется
+  в новом монолите (после адаптации под платформу)

Makefile

@@ -1,40 +1,27 @@
-# Создано: 2026-04-12
+# Makefile — монолит iot-service (образ naeel/iot-service).
-# Makefile для IoT managed service.
+# Старые k8s-цели — в legacy/Makefile.old.
 
-IMG ?= naeel/iot-operator:latest
+VERSION ?= v0.1.13
+IMAGE ?= naeel/iot-service
+LDFLAGS = -X main.version=$(VERSION)
 
-.PHONY: build build-all docker-build docker-push test tidy
+.PHONY: build vet test tidy docker-build docker-push
 
-# Собрать все бинарники
+build:
-build-all: build-operator build-bridge build-consumer
+	CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/iot-service ./cmd/iot-service/
 
-build-operator:
+vet:
-CGO_ENABLED=0 go build -o bin/iot-operator ./cmd/iot-operator/
+	go vet ./...
 
-build-bridge:
-CGO_ENABLED=0 go build -o bin/mqtt-bridge ./cmd/mqtt-bridge/
-
-build-consumer:
-CGO_ENABLED=0 go build -o bin/kafka-consumer ./cmd/kafka-consumer/
-
-# Docker
-docker-build:
-docker build -t $(IMG) .
-
-docker-push:
-docker push $(IMG)
-
-# Тесты и go mod
 test:
-go test ./...
+	go test ./...
 
 tidy:
-go mod tidy
+	go mod tidy
 
-# Применить CRD в кластер
+docker-build:
-install-crd:
+	docker build --build-arg VERSION=$(VERSION) -t $(IMAGE):$(VERSION) -t $(IMAGE):latest .
-kubectl apply -f config/crd/bases/
 
-# Деплой всех компонентов
+docker-push:
-deploy:
+	docker push $(IMAGE):$(VERSION)
-kubectl apply -f deployments/k8s/
+	docker push $(IMAGE):latest

README.md

@@ -1,71 +0,0 @@
-# IoT Managed Service
-
-## Назначение
-
-IoT Managed Service — это облачный сервис для управления IoT-устройствами, сбора и хранения телеметрии, а также интеграции с внешними системами через MQTT, Kafka и REST API.
-
-Сервис автоматизирует регистрацию устройств, выдачу credentials, сбор телеметрии и предоставляет REST-интерфейс для управления и мониторинга.
-
----
-
-## Архитектура
-
-- **IoT Device** — физическое устройство, подключающееся по MQTT
-- **EMQX** — брокер MQTT, делегирует auth/ACL в iot-operator
-- **iot-mqtt-bridge** — подписка на все топики, проксирует в Kafka
-- **Kafka** — очередь событий телеметрии
-- **iot-kafka-consumer** — сохраняет телеметрию в per-tenant Postgres
-- **IoT Postgres** — база данных для хранения телеметрии
-- **REST API** — управление устройствами, получение телеметрии
-
----
-
-## Основные компоненты
-
-| Компонент         | Назначение                        |
-|-------------------|-----------------------------------|
-| iot-operator      | REST API, контроллер CRD          |
-| iot-mqtt-bridge   | MQTT → Kafka                      |
-| iot-kafka-consumer| Kafka → Postgres                  |
-| iot-postgres      | Хранение телеметрии               |
-| EMQX              | MQTT брокер                       |
-
----
-
-## Основные команды и эндпоинты
-
-### Публичные
-- `GET /console` — IoT Console (SPA)
-- `GET /iot-admin` — страница администратора
-
-### JWT (namespace)
-- `POST /v1/namespaces/{ns}/iot/devices` — создать устройство
-- `GET /v1/namespaces/{ns}/iot/devices` — список устройств
-- `GET /v1/namespaces/{ns}/iot/devices/{name}` — получить устройство + пароль
-- `DELETE /v1/namespaces/{ns}/iot/devices/{name}` — удалить устройство
-- `PATCH /v1/namespaces/{ns}/iot/devices/{name}` — обновить (enabled)
-- `GET /v1/namespaces/{ns}/iot/telemetry` — получить телеметрию
-
-### Внутренние (без JWT)
-- `POST /internal/mqtt/auth` — MQTT auth для EMQX
-- `POST /internal/mqtt/acl` — MQTT ACL для EMQX
-
-### Админ
-- `GET /iot-admin/stats` — статистика (PG, Kafka, pods)
-
----
-
-## Быстрый старт
-
-1. Развернуть EMQX, iot-mqtt-bridge, event-dispatcher, iot-kafka-consumer, iot-postgres (см. deployments/k8s/)
-2. Зарегистрировать устройство через REST API или CRD
-3. Подключить устройство к MQTT (логин/пароль выдаются автоматически)
-4. Телеметрия автоматически попадёт в Postgres и доступна через REST API
-
----
-
-## Документация
-- doc/architecture/overview.md — архитектура
-- doc/api/endpoints.md — список эндпоинтов
-- doc/deployment.md — деплой и инженерные детали
-- examples/README.md — пример E2E цепочки

api/v1alpha1/device_types.go

@@ -1,3 +1,6 @@
+// ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (CRD-типы). В новой архитектуре заменяется таблицей iot_devices в PG.
+// Актуальное: HISTORY/2026-08-16-session-log.md
+
 // Создано: 2026-04-04
 // Описание CRD IoTDevice — регистрация IoT-устройства в платформе sless.
 // Пользователь создаёт IoTDevice, контроллер автоматически генерирует MQTT-credentials

api/v1alpha1/groupversion_info.go

@@ -1,3 +1,6 @@
+// ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (CRD-типы). В новой архитектуре не используется.
+// Актуальное: HISTORY/2026-08-16-session-log.md
+
 // Создано: 2026-04-04
 // groupversion_info.go — регистрация API group iot.kube5s.ru/v1alpha1.
 // ВАЖНО: группа намеренно отдельная от sless.kube5s.ru — при выносе IoT в

cmd/iot-operator/main.go

@@ -0,0 +1,148 @@
+// ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (оператор, CRD-контроллер). В новой архитектуре не используется.
+// Актуальное: HISTORY/2026-08-16-session-log.md
+
+// Создано: 2026-04-12
+// main.go — точка входа IoT managed service.
+// Запускает controller-manager (IoTDevice CRD) и REST API сервер (порт 9090) в одном процессе.
+// Перенесено из sless/main.go — только IoT-специфичная часть.
+//
+// Компоненты:
+//   1. Controller-Manager (controller-runtime) — reconcile IoTDevice CRD
+//   2. REST API Server (gorilla/mux) — CRUD устройств, телеметрия, MQTT auth, admin
+//
+// Конфигурация через env vars:
+//   IOT_PG_DSN     — DSN для IoT Postgres (опционально)
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/healthz"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+
+	iotv1alpha1 "gitea.services.ngcloud.ru/Nail/IoT/api/v1alpha1"
+	iotcontrollers "gitea.services.ngcloud.ru/Nail/IoT/controllers"
+	iotapi "gitea.services.ngcloud.ru/Nail/IoT/internal/api"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/api/handler"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+)
+
+var scheme = runtime.NewScheme()
+
+func init() {
+	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
+	// IoT API group iot.kube5s.ru/v1alpha1
+	utilruntime.Must(iotv1alpha1.AddToScheme(scheme))
+}
+
+func main() {
+	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
+	ctrl.SetLogger(zap.New(zap.UseDevMode(true)))
+
+	log.Info("starting IoT managed service operator")
+
+	// Controller Manager — управляет reconcile loop для IoTDevice CRD
+	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
+		Scheme:                 scheme,
+		HealthProbeBindAddress: ":8081",
+		LeaderElection:         false,
+	})
+	if err != nil {
+		log.Error("unable to create controller manager", "err", err)
+		os.Exit(1)
+	}
+
+	// Регистрируем IoTDevice controller
+	if err = (&iotcontrollers.IoTDeviceReconciler{
+		Client: mgr.GetClient(),
+		Scheme: mgr.GetScheme(),
+	}).SetupWithManager(mgr); err != nil {
+		log.Error("unable to create IoTDevice controller", "err", err)
+		os.Exit(1)
+	}
+
+	// Health/ready пробы для k8s
+	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
+		log.Error("unable to set up health check", "err", err)
+		os.Exit(1)
+	}
+	if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {
+		log.Error("unable to set up ready check", "err", err)
+		os.Exit(1)
+	}
+
+	// IoT Postgres — опционален (если IOT_PG_DSN не задан — телеметрия отключена)
+	iotPGStore, err := iotpg.NewFromEnv(log)
+	if err != nil {
+		log.Error("failed to init IoT Postgres", "err", err)
+		os.Exit(1)
+	}
+	if iotPGStore != nil {
+		defer iotPGStore.Close()
+	}
+
+	// REST API handler
+	h := &handler.Handler{
+		K8s:            mgr.GetClient(),
+		Scheme:         mgr.GetScheme(),
+		IoTPG:          iotPGStore,
+		Log:            log,
+		BridgeUsername: os.Getenv("MQTT_BRIDGE_USERNAME"),
+		BridgePassword: os.Getenv("MQTT_BRIDGE_PASSWORD"),
+	}
+
+	router := iotapi.NewRouter(h, log)
+
+	// HTTP API сервер на порту 9090
+	apiServer := &http.Server{
+		Addr:         ":9090",
+		Handler:      router,
+		ReadTimeout:  30 * time.Second,
+		WriteTimeout: 60 * time.Second,
+	}
+
+	// Запускаем API сервер в горутине
+	go func() {
+		log.Info("starting REST API server", "addr", ":9090")
+		if err := apiServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Error("API server failed", "err", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Graceful shutdown
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
+	defer cancel()
+
+	// Запускаем controller-manager (блокирует до ctx.Done)
+	go func() {
+		log.Info("starting controller manager")
+		if err := mgr.Start(ctx); err != nil {
+			log.Error("controller manager failed", "err", err)
+			os.Exit(1)
+		}
+	}()
+
+	<-ctx.Done()
+	log.Info("shutting down IoT operator")
+
+	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer shutdownCancel()
+	if err := apiServer.Shutdown(shutdownCtx); err != nil {
+		log.Error("API server shutdown error", "err", err)
+	}
+
+	fmt.Println("IoT operator stopped")
+}

cmd/iot-service/main.go

@@ -0,0 +1,137 @@
+// iot-service — монолит IoT на платформе Nubes (контейнер «Простой HTTP»).
+//
+// Три роли в одном процессе:
+//   - REST API + MQTT auth/acl (:9090, устройства в PostgreSQL);
+//   - bridge — MQTT-подписка EMQX → shared-SQS;
+//   - consumer — shared-SQS → per-tenant PostgreSQL.
+//
+// Наследие старого IoT (k8s, оператор, CRD) НЕ используется.
+package main
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/api"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/api/handler"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/bridge"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/config"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/consumer"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/sqsclient"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/store"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+)
+
+// version — подставляется через ldflags при сборке.
+var version = "dev"
+
+func main() {
+	cfg, err := config.Load()
+	if err != nil {
+		slog.Error("config", "err", err)
+		os.Exit(1)
+	}
+
+	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: cfg.LogLevel}))
+	slog.SetDefault(log)
+
+	log.Info("iot-service starting", "version", version, "port", cfg.APIPort)
+
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
+	defer cancel()
+
+	// PostgreSQL — устройства и телеметрия.
+	storeCtx, storeCancel := context.WithTimeout(ctx, 15*time.Second)
+	devices, err := store.Open(storeCtx, cfg.IOTPGDSN)
+	storeCancel()
+	if err != nil {
+		log.Error("devices store", "err", err)
+		os.Exit(1)
+	}
+	defer devices.Close()
+	log.Info("devices store ready")
+
+	// Служебная строка бриджа в iot_devices — для PG-auth EMQX (хвост 3).
+	ensureCtx, ensureCancel := context.WithTimeout(ctx, 10*time.Second)
+	err = devices.EnsureBridgeDevice(ensureCtx, cfg.MQTTUsername, cfg.MQTTPassword)
+	ensureCancel()
+	if err != nil {
+		log.Error("ensure bridge device", "err", err)
+		os.Exit(1)
+	}
+	log.Info("bridge device ensured", "username", cfg.MQTTUsername)
+
+	iotStore, err := iotpg.New(cfg.IOTPGDSN, log)
+	if err != nil {
+		log.Error("iotpg store", "err", err)
+		os.Exit(1)
+	}
+	defer iotStore.Close()
+	log.Info("telemetry store ready")
+
+	sqsClient := sqsclient.New(cfg)
+
+	h := &handler.Handler{
+		Devices:   devices,
+		IoTPG:     iotStore,
+		SQS:       sqsClient,
+		Cfg:       cfg,
+		Log:       log,
+		Version:   version,
+		StartedAt: time.Now(),
+	}
+
+	// HTTP API — в основном потоке.
+	router := api.NewRouter(h, log, cfg.AuthTestMode, cfg.JwtHMACSecret, version)
+	server := &http.Server{
+		Addr:              ":" + cfg.APIPort,
+		Handler:           router,
+		ReadHeaderTimeout: 10 * time.Second,
+	}
+
+	// bridge + consumer — в фоне.
+	var wg sync.WaitGroup
+	wg.Add(2)
+
+	go func() {
+		defer wg.Done()
+		if err := bridge.Run(ctx, cfg, sqsClient, log); err != nil && !errors.Is(err, context.Canceled) {
+			log.Error("bridge stopped", "err", err)
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+		if err := consumer.Run(ctx, cfg, sqsClient, iotStore, log); err != nil && !errors.Is(err, context.Canceled) {
+			log.Error("consumer stopped", "err", err)
+		}
+	}()
+
+	// Сервер гаснет ПОСЛЕДНИМ: сначала останавливаются bridge+consumer
+	// (ctx → disconnect MQTT → flush SQS), потом HTTP. Иначе платформа
+	// может убить контейнер по liveness, пока bridge/consumer ещё работают
+	// (фикс MEDIUM из ревью 2026-08-16).
+	go func() {
+		<-ctx.Done()
+		wg.Wait()
+		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer shutdownCancel()
+		_ = server.Shutdown(shutdownCtx)
+	}()
+
+	log.Info("iot-service listening", "addr", server.Addr)
+	if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		log.Error("http server", "err", err)
+		os.Exit(1)
+	}
+
+	wg.Wait()
+	log.Info("iot-service stopped")
+}

cmd/mqtt-bridge/main.go

@@ -0,0 +1,255 @@
+// Создано: 2026-04-04
+// Изменено: 2026-04-12 (замена Kafka → shared-SQS)
+// mqtt-bridge/main.go — сервис-мост: MQTT (EMQX) → shared-SQS.
+//
+// Роль в архитектуре:
+//   IoT Device → MQTT PUBLISH → EMQX → [mqtt-bridge подписан на "+/telemetry/+"]
+//   → SQS очередь "iot-telemetry"
+//   → iot-sqs-consumer → Postgres (история телеметрии)
+//   → event-dispatcher → Serverless Functions (триггеры)
+//
+// Логика:
+//   1. Подключиться к EMQX как MQTT клиент (credentials из env)
+//   2. Подписаться на топик "+/telemetry/+" (any namespace / telemetry / any device)
+//   3. При получении сообщения — отправить в SQS очередь "iot-telemetry"
+//   4. Payload оборачивается в envelope с метаданными (namespace, device_id, ts)
+//
+// Конфигурация через env vars:
+//   MQTT_BROKER_URL  — tcp://emqx.sless.svc:1883
+//   MQTT_USERNAME    — username для подключения bridge к EMQX
+//   MQTT_PASSWORD    — пароль bridge клиента
+//   SQS_ENDPOINT     — https://qu.kube5s.ru (или внутрикластерный endpoint)
+//   SQS_ACCESS_KEY   — Access Key для shared-SQS tenant
+//   SQS_SECRET_KEY   — Secret Key для shared-SQS tenant
+//   SQS_QUEUE_NAME   — имя очереди (default: iot-telemetry)
+//   SQS_REGION       — регион (default: us-east-1)
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	mqtt "github.com/eclipse/paho.mqtt.golang"
+)
+
+// mqttBridgeConfig — конфигурация сервиса из env vars.
+type mqttBridgeConfig struct {
+	MQTTBrokerURL string
+	MQTTUsername  string
+	MQTTPassword  string
+	SQSEndpoint   string
+	SQSAccessKey  string
+	SQSSecretKey  string
+	SQSQueueName  string
+	SQSRegion     string
+}
+
+// iotTelemetryMessage — envelope сообщения публикуемого в SQS.
+// Потребители (iot-sqs-consumer, event-dispatcher) читают этот формат.
+type iotTelemetryMessage struct {
+	// Namespace — k8s namespace тенанта (из MQTT topic, первый сегмент)
+	Namespace string `json:"namespace"`
+	// DeviceID — идентификатор устройства (из MQTT topic, третий сегмент)
+	DeviceID string `json:"device_id"`
+	// Topic — оригинальный MQTT topic
+	Topic string `json:"topic"`
+	// Payload — данные от устройства (JSON as-is, или строка если не JSON)
+	Payload json.RawMessage `json:"payload"`
+	// ReceivedAt — время получения сообщения мостом (UTC, RFC3339)
+	ReceivedAt string `json:"received_at"`
+}
+
+func main() {
+	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
+
+	cfg := loadBridgeConfig()
+
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
+	defer cancel()
+
+	log.Info("starting iot-mqtt-bridge",
+		"mqtt_broker", cfg.MQTTBrokerURL,
+		"mqtt_username", cfg.MQTTUsername,
+		"sqs_endpoint", cfg.SQSEndpoint,
+		"sqs_queue", cfg.SQSQueueName,
+	)
+
+	// SQS клиент через AWS SDK Go v2. Endpoint переопределяем на shared-SQS.
+	sqsClient := sqs.New(sqs.Options{
+		Region: cfg.SQSRegion,
+		Credentials: credentials.NewStaticCredentialsProvider(
+			cfg.SQSAccessKey, cfg.SQSSecretKey, "",
+		),
+		BaseEndpoint: aws.String(cfg.SQSEndpoint),
+	})
+
+	// Получаем QueueUrl по имени — SQS API требует URL, а не имя очереди.
+	// Делаем это один раз при старте.
+	queueUrlOut, err := sqsClient.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
+		QueueName: aws.String(cfg.SQSQueueName),
+	})
+	if err != nil {
+		log.Error("failed to get SQS queue URL — очередь должна существовать", "queue", cfg.SQSQueueName, "err", err)
+		os.Exit(1)
+	}
+	queueURL := *queueUrlOut.QueueUrl
+	log.Info("SQS queue resolved", "queue_url", queueURL)
+
+	// Создаём MQTT клиент
+	mqttClient, err := connectMQTT(cfg, log)
+	if err != nil {
+		log.Error("failed to connect to MQTT broker", "err", err)
+		os.Exit(1)
+	}
+	defer mqttClient.Disconnect(500)
+
+	// Функция-обработчик MQTT сообщений — отправляет envelope в SQS
+	messageHandler := buildMQTTMessageHandler(ctx, sqsClient, queueURL, log)
+
+	// Подписываемся на все telemetry топики всех namespace
+	// "+/telemetry/+" = {любой namespace}/telemetry/{любой deviceId}
+	const telemetryTopicFilter = "+/telemetry/+"
+	token := mqttClient.Subscribe(telemetryTopicFilter, 1, messageHandler)
+	token.Wait()
+	if token.Error() != nil {
+		log.Error("mqtt subscribe failed", "topic", telemetryTopicFilter, "err", token.Error())
+		os.Exit(1)
+	}
+	log.Info("subscribed to MQTT topic", "filter", telemetryTopicFilter)
+
+	<-ctx.Done()
+	log.Info("shutting down iot-mqtt-bridge")
+}
+
+// loadBridgeConfig читает конфигурацию из env vars.
+func loadBridgeConfig() mqttBridgeConfig {
+	required := func(key string) string {
+		v := os.Getenv(key)
+		if v == "" {
+			slog.Error("required env var not set", "key", key)
+			os.Exit(1)
+		}
+		return v
+	}
+
+	return mqttBridgeConfig{
+		MQTTBrokerURL: getEnvOrDefault("MQTT_BROKER_URL", "tcp://emqx.sless.svc:1883"),
+		MQTTUsername:  required("MQTT_USERNAME"),
+		MQTTPassword:  required("MQTT_PASSWORD"),
+		SQSEndpoint:   required("SQS_ENDPOINT"),
+		SQSAccessKey:  required("SQS_ACCESS_KEY"),
+		SQSSecretKey:  required("SQS_SECRET_KEY"),
+		SQSQueueName:  getEnvOrDefault("SQS_QUEUE_NAME", "iot-telemetry"),
+		SQSRegion:     getEnvOrDefault("SQS_REGION", "us-east-1"),
+	}
+}
+
+func getEnvOrDefault(key, defaultVal string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return defaultVal
+}
+
+// connectMQTT устанавливает подключение к EMQX брокеру.
+func connectMQTT(cfg mqttBridgeConfig, log *slog.Logger) (mqtt.Client, error) {
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(cfg.MQTTBrokerURL)
+	opts.SetClientID("sless-iot-bridge")
+	opts.SetUsername(cfg.MQTTUsername)
+	opts.SetPassword(cfg.MQTTPassword)
+	opts.SetAutoReconnect(true)
+	opts.SetConnectRetry(true)
+	opts.SetConnectRetryInterval(5 * time.Second)
+	opts.SetKeepAlive(30 * time.Second)
+	opts.SetCleanSession(false)
+
+	opts.SetConnectionLostHandler(func(_ mqtt.Client, err error) {
+		log.Warn("MQTT connection lost, reconnecting...", "err", err)
+	})
+	opts.SetReconnectingHandler(func(_ mqtt.Client, _ *mqtt.ClientOptions) {
+		log.Info("MQTT reconnecting...")
+	})
+	opts.SetOnConnectHandler(func(_ mqtt.Client) {
+		log.Info("MQTT connected to broker")
+	})
+
+	client := mqtt.NewClient(opts)
+	token := client.Connect()
+	if !token.WaitTimeout(30 * time.Second) {
+		return nil, fmt.Errorf("MQTT connect timeout")
+	}
+	if token.Error() != nil {
+		return nil, fmt.Errorf("MQTT connect: %w", token.Error())
+	}
+	return client, nil
+}
+
+// buildMQTTMessageHandler возвращает обработчик MQTT сообщений.
+// При получении — формирует envelope и отправляет в SQS очередь.
+// MessageGroupId = namespace (для FIFO очередей — группировка по тенанту).
+func buildMQTTMessageHandler(ctx context.Context, sqsClient *sqs.Client, queueURL string, log *slog.Logger) mqtt.MessageHandler {
+	return func(_ mqtt.Client, msg mqtt.Message) {
+		topic := msg.Topic()
+		payload := msg.Payload()
+
+		// Топик: "{namespace}/telemetry/{deviceId}"
+		parts := strings.SplitN(topic, "/", 3)
+		if len(parts) != 3 {
+			log.Warn("unexpected MQTT topic format, skipping", "topic", topic)
+			return
+		}
+		ns := parts[0]
+		deviceID := parts[2]
+
+		// Нормализуем payload: если не JSON — оборачиваем в строку
+		rawPayload := json.RawMessage(payload)
+		if !json.Valid(payload) {
+			quotedBytes, _ := json.Marshal(string(payload))
+			rawPayload = json.RawMessage(quotedBytes)
+		}
+
+		envelope := iotTelemetryMessage{
+			Namespace:  ns,
+			DeviceID:   deviceID,
+			Topic:      topic,
+			Payload:    rawPayload,
+			ReceivedAt: time.Now().UTC().Format(time.RFC3339),
+		}
+
+		body, err := json.Marshal(envelope)
+		if err != nil {
+			log.Error("marshal telemetry message", "topic", topic, "err", err)
+			return
+		}
+
+		// Отправляем в SQS. SendMessage — синхронный, но HTTP round-trip быстрый.
+		// При ошибке логируем и продолжаем — не блокируем MQTT callback надолго.
+		_, err = sqsClient.SendMessage(ctx, &sqs.SendMessageInput{
+			QueueUrl:    aws.String(queueURL),
+			MessageBody: aws.String(string(body)),
+		})
+		if err != nil {
+			log.Error("SQS SendMessage failed", "queue_url", queueURL, "err", err)
+			return
+		}
+
+		log.Info("forwarded IoT telemetry to SQS",
+			"mqtt_topic", topic,
+			"namespace", ns,
+			"device", deviceID,
+			"sqs_queue", queueURL,
+		)
+	}
+}

cmd/sqs-consumer/main.go

@@ -0,0 +1,207 @@
+// Создано: 2026-04-12 (замена kafka-consumer → sqs-consumer)
+// sqs-consumer/main.go — iot-sqs-consumer: читает IoT телеметрию из shared-SQS → пишет в Postgres.
+//
+// Роль в архитектуре:
+//   SQS очередь "iot-telemetry" → iot-sqs-consumer → IoT Postgres (per-tenant DB)
+//
+// Long polling (WaitTimeSeconds=20) — минимизирует пустые запросы к SQS.
+// При временной недоступности Postgres — сообщения остаются в очереди (visibility timeout).
+// DeleteMessage вызывается только после успешной записи в Postgres.
+//
+// Конфигурация через env vars:
+//   SQS_ENDPOINT   — https://qu.kube5s.ru (или внутрикластерный endpoint)
+//   SQS_ACCESS_KEY — Access Key для shared-SQS tenant
+//   SQS_SECRET_KEY — Secret Key для shared-SQS tenant
+//   SQS_QUEUE_NAME — имя очереди (default: iot-telemetry)
+//   SQS_REGION     — регион (default: us-east-1)
+//   IOT_PG_DSN     — postgres://user:pass@host:5432/iotdb (master DSN для IoT Postgres)
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+)
+
+// sqsConsumerConfig — конфигурация из env vars.
+type sqsConsumerConfig struct {
+	SQSEndpoint  string
+	SQSAccessKey string
+	SQSSecretKey string
+	SQSQueueName string
+	SQSRegion    string
+}
+
+// iotTelemetryMessage — envelope из SQS (идентичен bridge).
+type iotTelemetryMessage struct {
+	Namespace  string          `json:"namespace"`
+	DeviceID   string          `json:"device_id"`
+	Topic      string          `json:"topic"`
+	Payload    json.RawMessage `json:"payload"`
+	ReceivedAt string          `json:"received_at"`
+}
+
+func main() {
+	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
+
+	cfg := loadConsumerConfig()
+
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
+	defer cancel()
+
+	log.Info("starting iot-sqs-consumer",
+		"sqs_endpoint", cfg.SQSEndpoint,
+		"sqs_queue", cfg.SQSQueueName,
+	)
+
+	// IoT Postgres — обязательный компонент для этого сервиса
+	iotStore, err := iotpg.NewFromEnv(log)
+	if err != nil || iotStore == nil {
+		log.Error("failed to connect to IoT Postgres — IOT_PG_DSN required", "err", err)
+		os.Exit(1)
+	}
+	defer iotStore.Close()
+	log.Info("connected to IoT Postgres")
+
+	// SQS клиент
+	sqsClient := sqs.New(sqs.Options{
+		Region: cfg.SQSRegion,
+		Credentials: credentials.NewStaticCredentialsProvider(
+			cfg.SQSAccessKey, cfg.SQSSecretKey, "",
+		),
+		BaseEndpoint: aws.String(cfg.SQSEndpoint),
+	})
+
+	// Получаем QueueUrl по имени один раз при старте
+	queueUrlOut, err := sqsClient.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
+		QueueName: aws.String(cfg.SQSQueueName),
+	})
+	if err != nil {
+		log.Error("failed to get SQS queue URL — очередь должна существовать", "queue", cfg.SQSQueueName, "err", err)
+		os.Exit(1)
+	}
+	queueURL := *queueUrlOut.QueueUrl
+	log.Info("SQS queue resolved", "queue_url", queueURL)
+
+	log.Info("sqs consumer ready, starting polling loop...")
+
+	// Polling loop — long polling (WaitTimeSeconds=20) минимизирует пустые запросы.
+	// При ошибке SQS — backoff 5 сек и продолжаем.
+	for {
+		if ctx.Err() != nil {
+			break
+		}
+
+		resp, err := sqsClient.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
+			QueueUrl:            aws.String(queueURL),
+			MaxNumberOfMessages: 10,
+			WaitTimeSeconds:     20, // long polling — SQS держит соединение до 20 сек
+		})
+		if err != nil {
+			if ctx.Err() != nil {
+				break // штатное завершение
+			}
+			log.Error("SQS ReceiveMessage failed", "err", err)
+			// Backoff при ошибках SQS — не спамим запросами
+			select {
+			case <-ctx.Done():
+			case <-time.After(5 * time.Second):
+			}
+			continue
+		}
+
+		for _, sqsMsg := range resp.Messages {
+			if sqsMsg.Body == nil {
+				continue
+			}
+
+			if err := processSQSTelemetry(ctx, *sqsMsg.Body, iotStore, log); err != nil {
+				log.Error("process telemetry message", "err", err, "message_id", derefStr(sqsMsg.MessageId))
+				// НЕ удаляем сообщение — оно вернётся в очередь после visibility timeout
+				continue
+			}
+
+			// Удаляем сообщение из SQS только после успешной записи в Postgres
+			_, err := sqsClient.DeleteMessage(ctx, &sqs.DeleteMessageInput{
+				QueueUrl:      aws.String(queueURL),
+				ReceiptHandle: sqsMsg.ReceiptHandle,
+			})
+			if err != nil {
+				log.Error("SQS DeleteMessage failed", "err", err, "message_id", derefStr(sqsMsg.MessageId))
+			}
+		}
+	}
+
+	log.Info("shutting down iot-sqs-consumer")
+}
+
+// processSQSTelemetry десериализует envelope из SQS и записывает в Postgres.
+func processSQSTelemetry(ctx context.Context, body string, store *iotpg.IoTPostgresStore, log *slog.Logger) error {
+	var envelope iotTelemetryMessage
+	if err := json.Unmarshal([]byte(body), &envelope); err != nil {
+		// Битое сообщение — логируем и пропускаем (не блокируем очередь)
+		log.Warn("failed to unmarshal telemetry envelope, skipping", "err", err, "raw", body)
+		return nil
+	}
+
+	// EnsureTenantDB идемпотентен — кэшируется после первого вызова
+	if err := store.EnsureTenantDB(ctx, envelope.Namespace); err != nil {
+		return err
+	}
+
+	if err := store.InsertTelemetry(ctx, envelope.Namespace, envelope.DeviceID, envelope.Payload); err != nil {
+		return err
+	}
+
+	log.Info("telemetry saved to Postgres",
+		"namespace", envelope.Namespace,
+		"device", envelope.DeviceID,
+	)
+	return nil
+}
+
+// loadConsumerConfig читает конфигурацию из env vars.
+func loadConsumerConfig() sqsConsumerConfig {
+	required := func(key string) string {
+		v := os.Getenv(key)
+		if v == "" {
+			slog.Error("required env var not set", "key", key)
+			os.Exit(1)
+		}
+		return v
+	}
+
+	return sqsConsumerConfig{
+		SQSEndpoint:  required("SQS_ENDPOINT"),
+		SQSAccessKey: required("SQS_ACCESS_KEY"),
+		SQSSecretKey: required("SQS_SECRET_KEY"),
+		SQSQueueName: getEnvOrDefault("SQS_QUEUE_NAME", "iot-telemetry"),
+		SQSRegion:    getEnvOrDefault("SQS_REGION", "us-east-1"),
+	}
+}
+
+func getEnvOrDefault(key, defaultVal string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return defaultVal
+}
+
+// derefStr — безопасная разыменовка строкового указателя.
+func derefStr(s *string) string {
+	if s == nil {
+		return ""
+	}
+	return *s
+}

controllers/iotdevice_controller.go

@@ -1,3 +1,6 @@
+// ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (CRD-контроллер). В новой архитектуре не используется.
+// Актуальное: HISTORY/2026-08-16-session-log.md
+
 // Создано: 2026-04-04
 // iotdevice_controller.go — контроллер IoTDevice CRD.
 // Логика Reconcile:

deployments/k8s/iot-mqtt-bridge.yaml

@@ -1,71 +0,0 @@
-# Создано: 2026-04-04
-# Изменено: 2026-04-06 (MQTT→Kafka: убран RABBITMQ_URL, добавлен KAFKA_BROKERS, v0.1.67)
-# Deployment iot-mqtt-bridge — MQTT→Kafka мост для IoT.
-#
-# Получает MQTT сообщения от EMQX (подписка на "+/telemetry/+")
-# и публикует в Kafka топик "iot.telemetry" (ключ = namespace).
-#
-# Credentials для MQTT подключения берутся из Secret iot-bridge-credentials.
-# Этот Secret нужно создать вручную ДО деплоя:
-#
-#   # 1. Создать IoTDevice для bridge через API:
-#   curl -X POST .../v1/namespaces/sless-bridge/iot/devices \
-#     -d '{"name":"bridge","device_id":"bridge","enabled":true}'
-#
-#   # 2. Получить credentials:
-#   MQTT_USERNAME=$(kubectl get secret iot-bridge -n sless-bridge -o jsonpath='{.data.mqtt-username}' | base64 -d)
-#   MQTT_PASSWORD=$(kubectl get secret iot-bridge -n sless-bridge -o jsonpath='{.data.mqtt-password}' | base64 -d)
-#
-#   # 3. Создать Secret для bridge Deployment (один раз):
-#   kubectl create secret generic iot-bridge-credentials -n sless \
-#     --from-literal=MQTT_USERNAME="$MQTT_USERNAME" \
-#     --from-literal=MQTT_PASSWORD="$MQTT_PASSWORD"
-#
-# Применение: kubectl apply -f deployments/k8s/iot-mqtt-bridge.yaml
-
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: iot-mqtt-bridge
-  namespace: sless
-  labels:
-    app: iot-mqtt-bridge
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: iot-mqtt-bridge
-  template:
-    metadata:
-      labels:
-        app: iot-mqtt-bridge
-    spec:
-      containers:
-        - name: mqtt-bridge
-          # Тот же образ что и оператор — оба бинаря в одном слое (manager + iot-mqtt-bridge).
-          # При смене версии оператора — менять тег и здесь.
-          image: pearlharbor.registryk8s.services.ngcloud.ru/naeel/sless-operator:v0.1.69
-          imagePullPolicy: Always
-          command: ["/iot-mqtt-bridge"]
-          env:
-            - name: MQTT_BROKER_URL
-              value: "tcp://emqx.sless.svc:1883"
-            - name: KAFKA_BROKERS
-              value: "kafka.sless.svc.cluster.local:9092"
-          envFrom:
-            - secretRef:
-                name: iot-bridge-credentials
-            # IOT_PG_DSN — сохранение телеметрии в Postgres (опционально)
-            - secretRef:
-                name: iot-postgres-secret
-                optional: true
-          resources:
-            requests:
-              memory: "32Mi"
-              cpu: "25m"
-            limits:
-              memory: "64Mi"
-              cpu: "100m"
-      imagePullSecrets:
-        - name: sless-registry-auth

deployments/k8s/iot-postgres.yaml

@@ -1,66 +0,0 @@
-# Создано: 2026-04-05
-# Postgres для IoT телеметрии — отдельный от sless postgres (тот для invocations логов).
-# Deployment (не StatefulSet) — для dev/demo. В prod заменить на managed Postgres.
-#
-# Суперюзер iot_admin используется оператором для:
-#   - CREATE USER tenant_{ns} + CREATE DATABASE tenant_{ns}
-#   - CREATE TABLE iot_telemetry в tenant DB
-# Клиенты НЕ имеют прямого доступа — только через REST API платформы.
----
-apiVersion: v1
-kind: Secret
-metadata:
-  name: iot-postgres-secret
-  namespace: sless
-stringData:
-  # Суперпользователь — для управления tenant databases
-  POSTGRES_USER: "iot_admin"
-  POSTGRES_PASSWORD: "iot-pg-super-2026"
-  POSTGRES_DB: "iot_platform"
-  # DSN для оператора и mqtt-bridge (superuser к management DB)
-  IOT_PG_DSN: "postgresql://iot_admin:iot-pg-super-2026@iot-postgres.sless.svc:5432/iot_platform?sslmode=disable"
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: iot-postgres
-  namespace: sless
-  labels:
-    app: iot-postgres
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: iot-postgres
-  template:
-    metadata:
-      labels:
-        app: iot-postgres
-    spec:
-      containers:
-        - name: postgres
-          image: postgres:16-alpine
-          ports:
-            - containerPort: 5432
-          envFrom:
-            - secretRef:
-                name: iot-postgres-secret
-          resources:
-            requests:
-              memory: "128Mi"
-              cpu: "100m"
-            limits:
-              memory: "512Mi"
-              cpu: "500m"
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: iot-postgres
-  namespace: sless
-spec:
-  selector:
-    app: iot-postgres
-  ports:
-    - port: 5432
-      targetPort: 5432

doc/architecture/overview.md

@@ -1,66 +0,0 @@
-# IoT Managed Service — Архитектура
-
-## Общая схема
-
-```
-IoT Device (MQTT CONNECT)
-    │ username="{ns}_{deviceId}", password=hex
-    ▼
-EMQX 5.5.1 (sless/emqx)
-    │ POST /internal/mqtt/auth → iot-operator:9090
-    │ POST /internal/mqtt/acl  → iot-operator:9090
-    ▼
-    │ MQTT PUBLISH → topic: "{ns}/telemetry/{deviceId}"
-    ▼
-iot-mqtt-bridge (cmd/mqtt-bridge)
-    │ подписка на "+/telemetry/+"
-    │ → Kafka topic "iot.telemetry"
-    ▼
-Kafka
-    ▼
-iot-kafka-consumer (cmd/kafka-consumer)
-    │ consumer group "iot-pg-consumer"
-    │ → per-tenant Postgres DB
-    ▼
-IoT Postgres (iot-postgres.sless.svc)
-    │ DB: tenant_{namespace}
-    │ Table: iot_telemetry
-    ▼
-REST API (iot-operator:9090)
-    │ GET /v1/namespaces/{ns}/iot/telemetry
-    ▼
-Пользователь (Terraform / UI Console)
-```
-
-## Компоненты
-
-| Компонент | Бинарник | Порт | Назначение |
-|-----------|----------|------|------------|
-| iot-operator | cmd/iot-operator | :9090 (API), :8081 (health) | Controller-manager + REST API |
-| mqtt-bridge | cmd/mqtt-bridge | — | MQTT→Kafka bridge |
-| kafka-consumer | cmd/kafka-consumer | — | Kafka→Postgres pipeline |
-
-## CRD
-
-- **IoTDevice** (`iot.kube5s.ru/v1alpha1`)
-  - Создание: пользователь через API / Terraform
-  - Controller генерирует MQTT credentials → k8s Secret
-  - Secret удаляется каскадно через OwnerReference
-
-## Хранение
-
-- **IoT Postgres** — отдельный от sless PG
-  - Management DB: `iot_platform` (таблица `tenant_credentials`)
-  - Per-tenant DB: `tenant_{namespace}` (таблица `iot_telemetry`)
-
-## Аутентификация
-
-- REST API (/v1/): Bearer JWT (middleware.Auth)
-- MQTT Auth (/internal/): вызывается EMQX, без JWT
-- Admin (/iot-admin/stats): ADMIN_STATS_TOKEN
-
-## Docker образ
-
-- `naeel/iot-operator` (Docker Hub)
-- Все 3 бинарника в одном образе
-- `command: ["/iot-operator"]` или `["/mqtt-bridge"]` или `["/kafka-consumer"]`

doc/deployment-nubes-production.md

@@ -0,0 +1,164 @@
+# Деплой IoT на платформе Nubes без kubectl (чужой кластер)
+
+**Версии на 2026-08-16:** `naeel/iot-emqx:v0.2.4`, `naeel/iot-service:v0.1.2`.
+Образы публичные на Docker Hub, каждый имеет РОВНО один EXPOSE
+(EMQX — 8083, iot-service — 9090). Поле порта в deck отсутствует — порт
+берётся из EXPOSE образа.
+
+Процедура не требует kubectl: вся конфигурация задаётся env в deck-UI при
+создании контейнеров. EMQX авторизует устройства напрямую в PostgreSQL
+(таблица `iot_devices`) — адрес монолита ему НЕ нужен (в этом суть PG-auth,
+см. HISTORY секцию 27).
+
+---
+
+## 0. Предусловия
+
+1. **PostgreSQL managed** (инстанс платформы):
+   - роль `iot_service` (LOGIN) с правами **CREATEROLE + CREATEDB**
+     (нужны iotpg для per-tenant БД);
+   - база `iotdb` (OWNER iot_service);
+   - **SSL обязателен** (pg_hba платформы: без шифрования соединение
+     отклоняется) — в DSN `sslmode=require`, в EMQX `ssl.enable=true`.
+2. **shared-SQS**: тенант с креды (AccessKey/SecretKey) и очередь
+   `iot-telemetry`. Внутренний endpoint тенанта вшит дефолтом в образ
+   iot-service (см. config/defaults.go) — для чужого кластера уточнить
+   внутренний адрес shared-sqs и задать через `SQS_ENDPOINT`.
+3. **Имена доменов** выбрать заранее (задаются в deck при создании
+   контейнера), например: `iot.containerk8s.dev.nubes.ru` (API) и
+   `exqx.containerk8s.dev.nubes.ru` (MQTT wss).
+
+## 1. PostgreSQL (разово)
+
+Подключаться к master инстанса (`postgresqlk8s-master.<instance-uid>.
+svc.cluster.local:5432`) из консоли/порт-форварда:
+
+```sql
+CREATE ROLE iot_service LOGIN PASSWORD '<сгенерировать>';
+ALTER ROLE iot_service CREATEROLE CREATEDB;
+-- БД создаётся с owner iot_service (ddl_user не может SET ROLE напрямую):
+GRANT iot_service TO <текущая роль>;
+CREATE DATABASE iotdb OWNER iot_service;
+REVOKE iot_service FROM <текущая роль>;
+```
+
+Таблицы (`iot_devices`, per-tenant БД телеметрии) создаются кодом
+автоматически при старте iot-service.
+
+## 2. EMQX (создаётся ПЕРВЫМ)
+
+Тип «Простой HTTP контейнер», образ `naeel/iot-emqx:v0.2.4`
+(или `latest` — но см. раздел 5 про обновления). CPU **≥ 1000m**
+(на квоте 500m загрузка 5–10 мин, dashboard падает с таймаутами).
+
+Env (ВСЕ при создании — после создания env не меняются):
+
+| Переменная | Значение |
+|---|---|
+| `EMQX_AUTHENTICATION__1__SERVER` | `postgresqlk8s-master.<uid>.svc.cluster.local:5432` |
+| `EMQX_AUTHENTICATION__1__DATABASE` | `iotdb` |
+| `EMQX_AUTHENTICATION__1__USERNAME` | `iot_service` |
+| `EMQX_AUTHENTICATION__1__PASSWORD` | пароль роли |
+| `EMQX_AUTHORIZATION__SOURCES__1__SERVER` | как AUTHENTICATION |
+| `EMQX_AUTHORIZATION__SOURCES__1__DATABASE` | `iotdb` |
+| `EMQX_AUTHORIZATION__SOURCES__1__USERNAME` | `iot_service` |
+| `EMQX_AUTHORIZATION__SOURCES__1__PASSWORD` | пароль роли |
+| `EMQX_LOG__CONSOLE_HANDLER__LEVEL` | `warning` |
+
+⚠ НЕ задавать `EMQX_AUTHENTICATION__1__URL` / `EMQX_AUTHORIZATION__SOURCES__1__URL`
+(это HTTP-auth старой схемы — уронит под с `unknown_fields "url"`).
+⚠ `${VAR}` в конфиге не интерпретируется; только официальные env-переопределения.
+
+Загрузка на CPU ≥1000m ~2 мин. Проверка: `curl https://<emqx-домен>/mqtt`
+должен вернуть `400` (Cowboy без subprotocol — норма); wss-рука через
+клиент с subprotocol `mqtt`.
+
+После создания получить из консоли deck **UUID namespace EMQX** — он нужен
+на шаге 3.
+
+## 3. iot-service (создаётся ВТОРЫМ)
+
+Образ `naeel/iot-service:v0.1.2`, CPU ≥ 500m, память ≥ 256Mi.
+
+Env:
+
+| Переменная | Значение | Обязательна |
+|---|---|---|
+| `IOT_PG_DSN` | `postgresql://iot_service:<пароль>@postgresqlk8s-master.<uid>.svc.cluster.local:5432/iotdb?sslmode=require` | да |
+| `SQS_ACCESS_KEY` | AccessKey тенанта shared-sqs | да |
+| `SQS_SECRET_KEY` | SecretKey тенанта shared-sqs | да |
+| `MQTT_USERNAME` | `iot-bridge` | да |
+| `MQTT_PASSWORD` | пароль бриджа (тот же, что в строке `__bridge` в iot_devices) | да |
+| `MQTT_HOST` | `containerk8s.<uuid-emqx>.svc.cluster.local` | да (иначе дефолт `emqx` не резолвится) |
+| `ADMIN_STATS_TOKEN` | токен для `/iot-admin/stats` | нет |
+| `AUTH_TEST_MODE` | `false` | нет (дефолт false) |
+
+Остальные дефолты вшиты в образ (API_PORT=9090, SQS_ENDPOINT, SQS_QUEUE_NAME,
+SQS_REGION, long-poll 20с, visibility 30с, MQTT_PORT=8083, MQTT_WS_PATH=/mqtt,
+MQTT_CLIENT_ID=iot-bridge, LOG_LEVEL=info).
+
+Строку бриджа (`namespace='__bridge'`, `device_id=iot-bridge`,
+`mqtt_password=MQTT_PASSWORD`) монолит создаёт сам при старте
+(EnsureBridgeDevice) — вручную ничего не создавать.
+
+Проверка: `GET https://<iot-домен>/health` → `{"status":"ok","version":"..."}`.
+Бридж в логах: `bridge: MQTT connected` + `bridge: subscribed`.
+
+## 4. Устройства (регистрация)
+
+Устройство создаётся через API (JWT Bearer; структурная проверка sub+exp,
+подпись на этом уровне не проверяется — периметр обеспечивает платформа):
+
+```bash
+# токен для API (sub+exp):
+TOKEN=$(python3 -c "import base64,json,time;h=base64.urlsafe_b64encode(b'{\"alg\":\"none\",\"typ\":\"JWT\"}').rstrip(b'=').decode();p=base64.urlsafe_b64encode(json.dumps({'sub':'admin','exp':int(time.time())+86400}).encode()).rstrip(b'=').decode();print(h+'.'+p+'.sig')")
+curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
+  -d '{"name":"dev1","device_id":"dev-001"}' \
+  https://<iot-домен>/v1/namespaces/<ns>/iot/devices
+```
+
+Ответ содержит `mqtt_username` = `<ns>_<device_id>` и `mqtt_password`.
+Повторный просмотр пароля: `GET /v1/namespaces/<ns>/iot/devices/<name>`.
+
+Устройство подключается:
+- URL: `wss://<emqx-домен>/mqtt`, подпротокол `mqtt`;
+- username `<ns>_<device_id>`, password из ответа API;
+- публикация: топик `<ns>/telemetry/<device_id>`;
+- подписка разрешена только на свой топик (ACL).
+
+Негативные auth-тесты (должны быть отказ): неверный пароль → CONNACK rc=4;
+неизвестный username → rc=5. Проверять через on_connect rc (rc из
+`paho.connect()` всегда 0 даже при отказе!).
+
+Телеметрия: `GET /v1/namespaces/<ns>/iot/telemetry?limit=100`
+(тоже JWT Bearer).
+
+## 5. Обновления образов
+
+Платформа кэширует `latest` зеркалом, а путь к образу фиксируется при
+создании контейнера. Без kubectl обновление = **пересоздание контейнера в
+deck с конкретным тегом** (`naeel/iot-emqx:v0.2.4`, `naeel/iot-service:v0.1.2`).
+В своём кластере (есть kubectl): `kubectl -n <ns> set image
+deployment/containerk8s app=<image>:<tag>` — зеркало подтянет уникальный тег.
+
+## 6. Диагностика (кратко)
+
+- EMQX не поднялся: `kubectl logs` (если доступен) или `curl` домена —
+  503 = под лежит; schema-ошибки видны в логах запуска
+  (`failed_to_check_schema`, `unknown_fields`).
+- Устройство не авторизуется: включить `EMQX_LOG__CONSOLE_HANDLER__LEVEL=debug`,
+  смотреть `authenticator_result`/`authentication_result` и CONNACK ReasonCode.
+- Бридж отваливается: в логах монолита `bridge: ...`; после рестарта EMQX
+  бридж переподписывается автоматически (фикс resubscribe в OnConnectHandler,
+  HISTORY секция 26).
+- Телеметрия не доходит: цепочка устройство → EMQX → бридж → SQS
+  `iot-telemetry` → consumer → PG; сверять счётчики по HISTORY секции 26.4.
+
+## 7. Известные ограничения платформы
+
+- Edge-шлюз платформы рвёт wss ~150с (тикет Nubes подготовлен) — внешние
+  устройства должны переподключаться; внутри кластера (бридж) проблем нет.
+- Внешний путь к SQS — таймауты ~31–33с (~5.5% запросов) и MSS-проблема;
+  монолит использует внутренний endpoint shared-sqs.
+- env фиксируются при создании контейнера; ошиблись — пересоздать.
+EOF

doc/progress.md

@@ -1,37 +0,0 @@
-# IoT Managed Service — Трекер прогресса
-
-## 2026-04-12: Перенос из sless в отдельную репу
-
-### Выполнено
-- [x] Создана репа https://gitea.services.ngcloud.ru/Nail/IoT
-- [x] Go модуль: `gitea.services.ngcloud.ru/Nail/IoT`
-- [x] Перенесены все IoT-компоненты из sless:
-  - `iot/api/v1alpha1/` → `api/v1alpha1/` (CRD types: IoTDevice)
-  - `iot/controllers/` → `controllers/` (IoTDevice reconciler)
-  - `iot/cmd/mqtt-bridge/` → `cmd/mqtt-bridge/` (MQTT→Kafka)
-  - `iot/cmd/kafka-consumer/` → `cmd/kafka-consumer/` (Kafka→Postgres)
-  - `internal/storage/iotpg/` → `internal/storage/iotpg/` (per-tenant PG)
-  - `internal/api/handler/iot_*.go` → `internal/api/handler/` (REST handlers)
-  - `internal/api/ui/iot-*.html` → `internal/api/ui/` (embedded HTML)
-  - `internal/api/middleware/` → `internal/api/middleware/` (auth, logging)
-  - `deployments/k8s/iot-*.yaml` + `kafka.yaml` → `deployments/k8s/`
-  - `config/crd/bases/` → `config/crd/bases/`
-  - `doc/iot/`, `examples/IOT/` → `doc/`, `examples/`
-- [x] Созданы новые файлы:
-  - `cmd/iot-operator/main.go` — точка входа (controller-manager + REST API)
-  - `internal/api/handler/handler.go` — упрощённый Handler (без S3/PG от sless)
-  - `internal/api/router.go` — только IoT маршруты
-  - `Dockerfile` — multi-stage build, 3 бинарника, distroless
-  - `Makefile` — build/docker/deploy команды
-  - `.gitignore`
-  - `.github/copilot-instructions.md`
-- [x] Все import paths заменены: `sless/iot/...` → `Nail/IoT/...`
-- [x] Все 3 бинарника собираются без ошибок (go build ./...)
-- [x] Запушено в Gitea
-
-### Следующие шаги
-- [ ] Docker build + push на Docker Hub (`naeel/iot-operator`)
-- [ ] Обновить k8s manifests для нового образа
-- [ ] Деплой в кластер
-- [ ] E2E тест: создание устройства → MQTT → Kafka → Postgres → API
-- [ ] Убрать IoT-код из sless (опционально, после подтверждения что всё работает)

doc/sqs-integration.md

@@ -0,0 +1,70 @@
+# Интеграция IoT ↔ shared-sqs: состояние и рекомендации
+
+> Составлено 2026-08-16 на основе работ по сервису shared-sqs (SQS-совместимая
+> очередь на платформе Nubes). IoT будет использовать shared-sqs так же, как
+> сам shared-sqs использует managed-сервисы платформы.
+
+## 1. Что такое shared-sqs (кратко)
+
+- SQS-совместимая очередь (AWS API), Go, multi-tenant, форк GoAWS.
+- Версия на проде: **v0.1.35**.
+- Внешний endpoint: `https://sqs.containerk8s.dev.nubes.ru` (регион `us-east-1`).
+- Внутренний endpoint (для подов в том же кластере Nubes, realm iot-naeel):
+  `http://containerk8s.f1ffb134-7d16-45bd-8bef-69f6ec8ab33c.svc.cluster.local:4100`
+- Реализовано: CreateQueue, GetQueueUrl, ListQueues, SendMessage(+Batch),
+  ReceiveMessage, DeleteMessage(+Batch), ChangeMessageVisibility(+Batch),
+  PurgeQueue, DeleteQueue, Get/SetQueueAttributes, TagQueue/Untag/List,
+  FIFO (порядок + dedup 5 мин), Dead Letter Queues (RedrivePolicy).
+- Лимиты: 50 очередей на тенанта, сообщение до 256 КБ, Receive 1–10 сообщений.
+
+## 2. Что сделано и проверено (состояние на 16.08)
+
+- Все тесты зелёные: api_test 22/22, sdk_test 15/15, FIFO/DLQ e2e PASS.
+- План проверок выполнен полностью (таймауты сервера, рестарты, long-poll,
+  CLI в нагрузке, память 2ч, граница лимита 50).
+- Нагрузка: 168 591 операция без единой сервисной ошибки.
+- Сравнение с Yandex YMQ: shared-sqs быстрее (p50 6–8мс из внутренней сети,
+  89–90мс из интернета против 60–62мс / 138–150мс у YMQ).
+
+## 3. Известные проблемы ПЛАТФОРМЫ (не сервиса)
+
+1. **Таймауты каждые 31–33с на внешнем пути** (интернет → шлюз Nubes): ~5.5%
+   запросов не получают ответ 30с. Доказано серверным tcpdump: в момент сбоя
+   запрос не доходит до пода; внутри кластера потерь нет (port-forward —
+   24977 раундов, 0 сбоев). Тикет в поддержку Nubes подготовлен.
+2. **MSS=1448** на шлюзе при MTU пода 1400/underlay 1450: тела >~1400 байт
+   могут виснуть ~51с (PMTUD сломан).
+
+## 4. Рекомендации по интеграции IoT → shared-sqs
+
+1. **Использовать AWS SDK** (aws-sdk-go или boto3) с переопределением
+   endpoint'а. Не писать свой HTTP-клиент.
+2. **Ходить по внутренней сети, если IoT на Nubes в том же кластере:**
+   внутренний URL из п.1 полностью обходит проблемный внешний шлюз —
+   таймаутов 31–33с и MTU-проблем там нет. Это главная рекомендация.
+3. **Клиентские ретраи обязательны:** retries ≥ 3, read_timeout ≥ 30с
+   (для внешнего пути). При внутреннем пути достаточно дефолтов.
+4. **Размер сообщений:** до ~1300 байт — безопасно всегда; большие тела —
+   только после фикса MSS шлюзом, либо бить на части.
+5. **Receive:** VisibilityTimeout ставьте с запасом на обработку (30с+);
+   `ChangeMessageVisibility(0)` — мгновенный возврат в очередь; long-poll
+   (WaitTimeSeconds) поддерживается.
+6. **FIFO:** обязателен `MessageGroupId`; dedup-окно 5 минут; порядок
+   гарантирован внутри группы.
+7. **DLQ:** настраивается RedrivePolicy (`deadLetterTargetArn`,
+   `maxReceiveCount`); ARN DLQ должен быть tenant-scoped (как в тестах).
+8. **Лимит:** 50 очередей на тенанта — держать список очередей под контролем.
+9. **Мониторинг:** `/health` отдаёт `{"status":"ok","version":...}`;
+   метрики платформы — Grafana (как для остальных managed-сервисов).
+
+## 5. Аутентификация
+
+- Креды тенанта детерминированы: tenantID `t-`+sha256(email)[:8],
+  AccessKey `SSAK-`+sha256(email)[:12],
+  SecretKey sha256(email+":shared-sqs:secret-key:v1").
+- IoT получит свой тенант/креды через консоль Nubes (как другие сервисы).
+
+## 6. Что осталось до полного прода
+
+- Отправить тикет Nubes (таймауты шлюза + MSS) — единственный блокер для
+  интернет-клиентов. Для внутренней интеграции IoT блокеров нет.

doc/thinking/2026-04-12.md

@@ -1,59 +0,0 @@
-# 2026-04-12 — GitHub Copilot (Claude Opus 4.6)
-
-## Задача
-Пользователь просит:
-1. Просмотреть всё в репе IoT
-2. Оценить замену Kafka и RabbitMQ на собственный SQS-service (из ~/terra/SQS-service)
-3. Контекст: проект переехал из ~/terra/sless в отдельную репу ~/remote_dev/IoT
-
-## План
-1. Изучить текущую структуру IoT репы — что есть, как используется Kafka
-2. Посмотреть SQS-service — что он из себя представляет
-3. Посмотреть старую репу sless — что оттуда переехало, что осталось
-4. Дать краткую оценку замены Kafka/RabbitMQ → SQS
-
-## Ход работы
-
-### Анализ: что нашёл
-
-**IoT — текущее использование Kafka:**
-- `cmd/mqtt-bridge/main.go` — MQTT → Kafka writer (топик `iot.telemetry`, библиотека `segmentio/kafka-go`)
-- `cmd/kafka-consumer/main.go` — Kafka reader → Postgres (consumer group `iot-pg-consumer`)
-- `internal/api/handler/iot_admin_stats_handler.go` — admin UI: показывает Kafka consumer lag
-- `cmd/iot-operator/main.go` — передаёт KAFKA_BROKERS в handler
-- `deployments/k8s/kafka.yaml` — деплоймент Kafka в кластере
-- В документации (deployment.md, iot-mvp-plan.md) упоминается RabbitMQ как изначальный план, но в коде **RabbitMQ нет** — в реальности уже Kafka
-
-**SQS-service (shared-sqs):**
-- AWS SQS-совместимый сервис на Go (модуль `shared-sqs`)
-- HTTP API с SQS-протоколом: CreateQueue, SendMessage, ReceiveMessage, DeleteMessage и т.д.
-- Multi-tenant: TenantStore с auth
-- Persistence: Redis (write-through) + in-memory
-- Billing через PostgreSQL
-- Порт 4100, gorilla/mux
-- **Не Kafka-совместимый** — это pull-based очередь (SQS-like), не streaming platform
-
-**RabbitMQ в IoT:** только в документах (plan). В коде не используется.
-
-**shared-SQS (из Gitea README):**
-- AWS SQS-совместимый managed сервис — 17 операций SQS
-- Уже задеплоен: endpoint `https://qu.kube5s.ru`, Web UI `https://qu.kube5s.ru/ui/`
-- Multi-tenant с auth (JWT nubes → auto-create tenant → Access Key / Secret Key)
-- Можно использовать через стандартные AWS SDK (Go, Python boto3, Node.js @aws-sdk/client-sqs)
-- Persistence: Redis + in-memory
-- Billing: PostgreSQL
-- Benchmark: конкурентоспособен с Yandex MQ
-
-### Выводы по замене Kafka → shared-SQS
-
-**Что реально нужно сделать в IoT:**
-1. `mqtt-bridge`: заменить `kafka.Writer` → AWS SDK SQS `SendMessage` (endpoint = qu.kube5s.ru или внутрикластерный)
-2. `kafka-consumer` → переименовать в `sqs-consumer`: заменить `kafka.Reader` → SQS `ReceiveMessage` + `DeleteMessage` polling loop
-3. `admin stats handler`: вместо Kafka lag → SQS `GetQueueAttributes` (ApproximateNumberOfMessages)
-4. Удалить `deployments/k8s/kafka.yaml`
-5. Убрать `segmentio/kafka-go` из go.mod, добавить `aws-sdk-go-v2`
-6. Обновить env vars: KAFKA_BROKERS → SQS_ENDPOINT + SQS credentials
-7. Обновить документацию
-
-**Плюс:** AWS SDK for Go — стандартная библиотека, код станет проще. shared-SQS уже живой.
-**Минус:** polling latency (ReceiveMessage WaitTimeSeconds до 20s) vs Kafka push. Для IoT телеметрии — приемлемо.

doc/thinking/nubes-devops-report-2026-08-16.md

@@ -0,0 +1,143 @@
+# Отчёт для DevOps Nubes — сетевые проблемы платформы
+
+**Кластер:** iot-naeel
+**Дата:** 2026-08-16
+**Статус:** предварительный, все факты подтверждены тестами и дампами.
+Готовы предоставить скрипты воспроизведения и провести совместные тесты.
+
+---
+
+## Часть 1. Что не работает (наблюдения и доказательства)
+
+### 1.1 Внешние WebSocket-соединения закрываются ~через 150 секунд
+
+**Симптом.** WebSocket-соединения из внешних сетей (wss, TLS) закрываются
+в районе 150 секунд после установления. Для клиентов это выглядит как
+разрыв без видимой причины (close 1006/1005) с необходимостью
+переподключения.
+
+**Доказательства.**
+- 5 из 5 внешних станций (разные сети) — разрыв ~150 с, стабильно.
+- Чистый VPS (Vultr) — 1 из 1, тот же разрыв ~150 с.
+- Внутри кластера (под → сервис) — 600 с без единого разрыва.
+- Машина за тем же шлюзом, но вне платформы — 300 с чисто.
+- Контрольные wss-соединения к внешним ресурсам (nginx, echo-серверы)
+  с тех же станций — чисто.
+
+**Вывод.** Обрывает именно edge-шлюз платформы (или балансировщик перед
+ним), по таймеру. Похоже на фиксированный лимит времени жизни
+соединения (idle/lifetime timeout) на проксирующем слое.
+
+**Влияние.** Любой долгоживущий протокол поверх WebSocket (например,
+MQTT) вынужден переподключаться каждые ~150 с. Наши клиенты это
+переживают (автопереподключение), но это лишний трафик и окна потерь.
+
+### 1.2 Зависание внешних соединений ~на 51 секунду при объёмном трафике (MTU)
+
+**Симптом.** Из внешней сети операции с телом/ответом крупнее ~1,4 КБ
+периодически «зависают» ровно на ~51 секунду, после чего либо
+завершаются, либо обрываются. Внутри кластера те же операции проходят
+мгновенно.
+
+**Доказательства (три независимых контура).**
+- Контур A (HTTP-сервис за платформой): POST снаружи — пауза ~51 с на
+  любом объёме данных выше порога; изнутри — мгновенно. При
+  внешнемTrafficPolicy: Cluster большие файлы (>5 МБ) дают TCP-stall
+  ровно на 51 с.
+- Контур B (очередь с AWS-совместимым API): тела >~1,4 КБ виснут ~51 с
+  (классическая экспонента TCP-ретрансмитов).
+- Контур C (REST API): HTTP-ответы крупнее ~15 КБ приходят частично и
+  виснут (в тесте получено 15 672 байта — далее стоп); маленькие ответы
+  (до ~15 КБ) проходят стабильно.
+
+**Диагностика (наша гипотеза, подтверждённая измерениями).**
+- Underlay MTU = 1450.
+- Оверлей (Cilium Geneve) добавляет ~50 байт инкапсуляции.
+- MTU контейнеров остаётся дефолтным 1500.
+- Кросс-нодовый пакет полного размера = 1500 + 50 = 1550 > 1450 →
+  фрагментация невозможна (DF) → пакет дропается → ядро ждёт
+  ретрансмиссии по экспоненте → суммарная пауза ~51 с.
+- На внешнем пути наблюдается MSS 1448 при MTU 1400 — т.е. ICMP
+  «fragmentation needed» до клиентов, вероятно, не доходит (PMTUD
+  сломан на каком-то из хопов).
+
+**Влияние.** Любой объёмный запрос/ответ снаружи рискует зависнуть на
+~51 с; клиенты с таймаутами 30 с получают «таймаут», хотя сервис
+ответил мгновенно.
+
+### 1.3 Периодические таймауты внешних запросов на малых объёмах (~5,5%)
+
+**Симптом.** Даже запросы размером ~512 байт снаружи в ~5,5% случаев не
+получают ответ 30+ секунд; характерный паттерн — зависание на 31–33 с.
+
+**Доказательства.**
+- Внутри кластера: 24 977 запросов подряд — 0 сбоев (порт-форвард).
+- Снаружи: периодические зависания подтверждены tcpdump-ом (запрос
+  уходит, ответ не возвращается в течение 30+ с).
+- Маловероятно, что это наша прикладная логика: те же операции изнутри
+  кластера стабильны.
+
+**Гипотеза.** Связь с пунктом 1.2 (потеря крупных сегментов при
+переговорах TLS/подтверждениях) или лимиты conntrack/сессий на
+балансировщике.
+
+---
+
+## Часть 2. Как это исправить (наши предложения)
+
+### 2.1 К пункту 1.1 (wss ~150 с)
+
+1. Найти слой, который закрывает соединения: проверить настройки
+   idle/lifetime timeout на edge-шлюзе и балансировщике перед кластером
+   (nginx: `proxy_read_timeout`, `proxy_send_timeout`; LB: idle timeout).
+2. Для wss-трафика выставить таймауты ≥ 600 с (или «без таймаута»).
+3. Включить WebSocket ping/pong на прокси-слое (keepalive-фреймы каждые
+   30–60 с), чтобы соединение не считалось простаивающим.
+4. После изменения — прогнать наш контрольный тест (wss-клиент держит
+   соединение 10 минут; критерий — 0 разрывов).
+
+### 2.2 К пункту 1.2 (MTU / 51 с)
+
+Варианты, в порядке предпочтения:
+
+1. **Включить MSS-clamping на внешнем пути** (на шлюзе/на узлах):
+   `iptables -t mangle -A FORWARD -p tcp --tcp-flags SYN,RST SYN \
+   -j TCPMSS --clamp-mss-to-pmtu` (или фиксированный MSS под MTU
+   внешнего интерфейса). Это дешёвое и надёжное решение: клиент не будет
+   слать сегменты крупнее, чем проходит путь.
+2. **Привести MTU контейнеров к underlay**: MTU подов 1450 − 50
+   (инкапсуляция) = 1400. Тогда кросс-нодовые пакеты перестанут
+   превышать underlay, и дропы исчезнут в принципе.
+3. **Проверить, что ICMP «fragmentation needed» не режется** на всём
+   внешнем пути (firewall/LB) — восстановление PMTUD решит проблему
+   для больших ответов.
+4. Отключить запрет фрагментации на edge для исходящих сегментов (менее
+   желательно).
+
+Критерий приёмки: POST/GET с телами 1 КБ…1 МБ снаружи проходят без
+пауз >2 с (наш тест: 100 запросов разных размеров, 0 зависаний).
+
+### 2.3 К пункту 1.3 (таймауты малых тел)
+
+1. Сначала применить 2.2 — вероятно, это тот же корень.
+2. Если проблема останется: проверить лимиты conntrack на шлюзе
+   (`nf_conntrack_max`, `table-full` в логах) и пул/лимиты соединений
+   балансировщика.
+3. Критерий: 10 000 запросов по 512 байт снаружи — 0 таймаутов.
+
+---
+
+## Что мы уже сделали со своей стороны (обходы)
+
+- Клиенты переподключаются автоматически (переживают пункт 1.1).
+- Внутренние взаимодействия ходят по внутренним DNS, минуя внешний
+  шлюз (таймауты 1.3 нас не блокируют).
+- Чтение больших списков разбито на страницы небольшого размера
+  (обход пункта 1.2).
+
+## Что нужно от вас
+
+1. Подтверждение/опровержение по каждому пункту.
+2. Если нужны воспроизведения — дайте окно и среду, прогоним тесты
+   совместно (скрипты готовы).
+3. Оценка сроков по пунктам 2.1–2.3.

emqx/Dockerfile

@@ -0,0 +1,14 @@
+# EMQX для IoT на платформе Nubes.
+# Образ: naeel/iot-emqx (Docker Hub, публичный).
+#
+# БАЗА — официальный emqx/emqx:5.5.1 (проверен на платформе: заводится, логи в
+# stdout). Добавляем только наш emqx.conf (auth/ACL, listeners, логи).
+# ⚠️ У образа 7 EXPOSE-портов (наследие базы) — deck-UI при СОЗДАНИИ требует
+# один порт; в НАШЕМ кластере используется kubectl set image, вопрос одного
+# EXPOSE для чужого кластера — отдельная задача (тикет Nubes).
+
+FROM emqx/emqx:5.5.1
+
+COPY emqx.conf /opt/emqx/etc/emqx.conf
+
+EXPOSE 8083

emqx/Makefile

@@ -0,0 +1,13 @@
+# EMQX-контейнер для IoT (образ naeel/iot-emqx).
+
+VERSION ?= v0.2.4
+IMAGE ?= naeel/iot-emqx
+
+.PHONY: docker-build docker-push
+
+docker-build:
+	docker build -t $(IMAGE):$(VERSION) -t $(IMAGE):latest .
+
+docker-push:
+	docker push $(IMAGE):$(VERSION)
+	docker push $(IMAGE):latest

emqx/emqx.conf

@@ -0,0 +1,119 @@
+## EMQX 5.x — конфиг для контейнера IoT на платформе Nubes.
+## Вшит в образ naeel/iot-emqx. Auth/ACL — напрямую в PostgreSQL (iot_devices),
+## без зависимости от адреса монолита: EMQX можно создать в deck ДО iot-service.
+##
+## ⚠ ${VAR}-интерполяция в этом конфиге НЕ работает (проверено на 5.5.1:
+## значения попадают в конфиг буквально). Параметры PG задаются ТОЛЬКО
+## официальными env-переопределениями (deck-UI или kubectl set env):
+##   EMQX_AUTHENTICATION__1__SERVER     — host:port master (внутренний svc)
+##   EMQX_AUTHENTICATION__1__DATABASE   — имя БД (iotdb)
+##   EMQX_AUTHENTICATION__1__USERNAME   — роль (iot_service)
+##   EMQX_AUTHENTICATION__1__PASSWORD   — пароль роли
+##   EMQX_AUTHORIZATION__SOURCES__1__SERVER / DATABASE / USERNAME / PASSWORD
+## SSL обязателен (pg_hba платформы): ssl = {enable=true, verify=verify_none}.
+## ⚠ В authz-postgresql НЕ поддерживаются плейсхолдеры ${action}/${topic} —
+## action/topic возвращаются КОЛОНКАМИ результата запроса (проверено на 5.5.1:
+## ${action} подставлялся как литерал "{action}" и ACL-запрос падал).
+
+node {
+  name = "emqx@127.0.0.1"
+  cookie = "iot-emqx-cookie-mvp"
+  data_dir = "/opt/emqx/data"
+}
+
+## Auth — PostgreSQL: устройства в iot_devices.
+## username устройства = namespace || '_' || device_id; бридж: namespace='__bridge',
+## username = device_id (строка создаётся монолитом EnsureBridgeDevice при старте).
+authentication = [
+  {
+    mechanism = password_based
+    backend = postgresql
+    enable = true
+    server = "127.0.0.1:5432"
+    database = "iotdb"
+    username = "iot_service"
+    password = "placeholder"
+    auto_reconnect = true
+    pool_size = 8
+    ssl {
+      enable = true
+      verify = verify_none
+    }
+    password_hash_algorithm {
+      name = plain
+      salt_position = disable
+    }
+    query = "SELECT mqtt_password AS password_hash FROM iot_devices WHERE enabled = true AND (namespace || '_' || device_id = ${username} OR (namespace = '__bridge' AND ${username} = device_id)) LIMIT 1"
+  }
+]
+
+## ACL — PostgreSQL: устройства pub/sub только в свой топик ns/telemetry/device_id,
+## бридж — subscribe на "+/telemetry/+".
+## no_match = deny: нет строки в iot_devices или устройство выключено — запрет.
+authorization {
+  no_match = deny
+  deny_action = disconnect
+  cache {
+    enable = true
+    max_size = 32
+    ttl = 1m
+  }
+  sources = [
+    {
+      type = postgresql
+      enable = true
+      server = "127.0.0.1:5432"
+      database = "iotdb"
+      username = "iot_service"
+      password = "placeholder"
+      auto_reconnect = true
+      pool_size = 8
+      ssl {
+        enable = true
+        verify = verify_none
+      }
+      query = "SELECT 'allow' AS permission, 'subscribe' AS action, '+/telemetry/+' AS topic FROM iot_devices WHERE enabled = true AND namespace = '__bridge' AND ${username} = device_id UNION ALL SELECT 'allow' AS permission, a.action, namespace || '/telemetry/' || device_id AS topic FROM iot_devices, (VALUES ('publish'), ('subscribe')) AS a(action) WHERE enabled = true AND namespace || '_' || device_id = ${username}"
+    }
+  ]
+}
+
+mqtt {
+  max_packet_size = 1MB
+  max_topic_levels = 10
+  retain_available = false
+}
+
+## Логи: console (stdout) — видны через kubectl logs платформы.
+## Файловый handler отключён (у USER emqx нет прав на /var/log/emqx при deb).
+log {
+  console_handler {
+    enable = true
+    level = warning
+  }
+  file_handlers.default {
+    enable = false
+  }
+}
+
+## Listeners: WebSocket — единственный порт контейнера платформы (8083).
+## TCP 1883 остаётся для диагностики (не экспонируется платформой).
+listeners.tcp.default {
+  bind = "0.0.0.0:1883"
+  max_connections = 1024
+}
+
+listeners.ws.default {
+  bind = "0.0.0.0:8083"
+  websocket {
+    mqtt_path = "/mqtt"
+  }
+  max_connections = 512
+}
+
+## Dashboard ОТКЛЮЧЁН (enable=false): на CPU-квоте 500m swagger-генерация падает
+## с таймаутами и засоряет логи. Диагностика — через порт 1883/ctl.
+dashboard {
+  listeners.http {
+    enable = false
+  }
+}

go.mod

@@ -3,11 +3,13 @@ module gitea.services.ngcloud.ru/Nail/IoT
 go 1.25
 
 require (
+	github.com/aws/aws-sdk-go-v2 v1.41.5
+	github.com/aws/aws-sdk-go-v2/credentials v1.19.14
+	github.com/aws/aws-sdk-go-v2/service/sqs v1.42.25
 	github.com/eclipse/paho.mqtt.golang v1.5.1
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/mux v1.8.1
 	github.com/lib/pq v1.11.2
-	github.com/segmentio/kafka-go v0.4.50
 	k8s.io/api v0.26.0
 	k8s.io/apimachinery v0.26.0
 	k8s.io/client-go v0.26.0
@@ -15,6 +17,9 @@ require (
 )
 
 require (
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 // indirect
+	github.com/aws/smithy-go v1.24.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
@@ -36,13 +41,11 @@ require (
 	github.com/imdario/mergo v0.3.6 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.15.9 // indirect
 	github.com/mailru/easyjson v0.7.6 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.2 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/pierrec/lz4/v4 v4.1.15 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.14.0 // indirect
 	github.com/prometheus/client_model v0.3.0 // indirect

go.sum

@@ -38,6 +38,18 @@ github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuy
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/aws/aws-sdk-go-v2 v1.41.5 h1:dj5kopbwUsVUVFgO4Fi5BIT3t4WyqIDjGKCangnV/yY=
+github.com/aws/aws-sdk-go-v2 v1.41.5/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.14 h1:n+UcGWAIZHkXzYt87uMFBv/l8THYELoX6gVcUvgl6fI=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.14/go.mod h1:cJKuyWB59Mqi0jM3nFYQRmnHVQIcgoxjEMAbLkpr62w=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 h1:Rgg6wvjjtX8bNHcvi9OnXWwcE0a2vGpbwmtICOsvcf4=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21/go.mod h1:A/kJFst/nm//cyqonihbdpQZwiUhhzpqTsdbhDdRF9c=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 h1:PEgGVtPoB6NTpPrBgqSE5hE/o47Ij9qk/SEZFbUOe9A=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21/go.mod h1:p+hz+PRAYlY3zcpJhPwXlLC4C+kqn70WIHwnzAfs6ps=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.42.25 h1:8Bv3TQ1Cob6HLlpUbAnWxeHhAkYScJO9RIHh2WPXaxw=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.42.25/go.mod h1:eDstEbM0OEnBUnNQxIA7j74Jy61cCU1S4EMlCtdMwzs=
+github.com/aws/smithy-go v1.24.2 h1:FzA3bu/nt/vDvmnkg+R8Xl46gmzEDam6mZ1hzmwXFng=
+github.com/aws/smithy-go v1.24.2/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
 github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
@@ -188,8 +200,6 @@ github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7V
 github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.15.9 h1:wKRjX6JRtDdrE9qwa4b/Cip7ACOshUI4smpCQanqjSY=
-github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
@@ -225,8 +235,6 @@ github.com/onsi/ginkgo/v2 v2.6.0 h1:9t9b9vRUbFq3C4qKFCGkVuq/fIHji802N1nrtkh1mNc=
 github.com/onsi/ginkgo/v2 v2.6.0/go.mod h1:63DOGlLAH8+REH8jUGdL3YpCpu7JODesutUjdENfUAc=
 github.com/onsi/gomega v1.24.1 h1:KORJXNNTzJXzu4ScJWssJfJMnJ+2QJqhoQSRwNlze9E=
 github.com/onsi/gomega v1.24.1/go.mod h1:3AOiACssS3/MajrniINInwbfOOtfZvplPzuRSmvt1jM=
-github.com/pierrec/lz4/v4 v4.1.15 h1:MO0/ucJhngq7299dKLwIMtgTfbkoSPF6AoMYDd8Q4q0=
-github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -260,8 +268,6 @@ github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1
 github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo=
 github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/segmentio/kafka-go v0.4.50 h1:mcyC3tT5WeyWzrFbd6O374t+hmcu1NKt2Pu1L3QaXmc=
-github.com/segmentio/kafka-go v0.4.50/go.mod h1:Y1gn60kzLEEaW28YshXyk2+VCUKbJ3Qr6DrnT3i4+9E=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
@@ -278,12 +284,6 @@ github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
-github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
-github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
-github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
-github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
-github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

internal/api/handler/handler.go

@@ -10,15 +10,15 @@
 package handler
 
 import (
-"encoding/json"
+	"encoding/json"
-"log/slog"
+	"log/slog"
-"net/http"
+	"net/http"
 
-"github.com/gorilla/mux"
+	"github.com/gorilla/mux"
-"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime"
-"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 
-"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
 )
 
 // defaultNamespace — fallback namespace для dev/тестов.
@@ -26,36 +26,38 @@ const defaultNamespace = "default"
 
 // Handler содержит зависимости для всех IoT REST-обработчиков.
 type Handler struct {
-K8s    client.Client
+	K8s    client.Client
-Scheme *runtime.Scheme
+	Scheme *runtime.Scheme
-// IoTPG — хранилище IoT телеметрии (per-tenant Postgres). nil если IOT_PG_DSN не задан.
+	// IoTPG — хранилище IoT телеметрии (per-tenant Postgres). nil если IOT_PG_DSN не задан.
-IoTPG *iotpg.IoTPostgresStore
+	IoTPG *iotpg.IoTPostgresStore
-// KafkaBrokers — адреса Kafka брокеров для чтения consumer lag на admin странице.
+	Log   *slog.Logger
-KafkaBrokers string
+	// BridgeUsername — username внутреннего MQTT bridge (env MQTT_BRIDGE_USERNAME)
-Log          *slog.Logger
+	BridgeUsername string
+	// BridgePassword — пароль bridge (env MQTT_BRIDGE_PASSWORD)
+	BridgePassword string
 }
 
 // writeJSON отправляет JSON-ответ с указанным статусом.
 func writeJSON(w http.ResponseWriter, status int, v any) {
-w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Content-Type", "application/json")
-w.WriteHeader(status)
+	w.WriteHeader(status)
-_ = json.NewEncoder(w).Encode(v)
+	_ = json.NewEncoder(w).Encode(v)
 }
 
 // errResp возвращает структуру ошибки для JSON.
 func errResp(msg string) map[string]string {
-return map[string]string{"error": msg}
+	return map[string]string{"error": msg}
 }
 
 // pathVar читает переменную пути из gorilla/mux.
 func pathVar(r *http.Request, key string) string {
-return mux.Vars(r)[key]
+	return mux.Vars(r)[key]
 }
 
 // namespace читает {namespace} из пути URL.
 func namespace(r *http.Request) string {
-if ns := mux.Vars(r)["namespace"]; ns != "" {
+	if ns := mux.Vars(r)["namespace"]; ns != "" {
-return ns
+		return ns
-}
+	}
-return defaultNamespace
+	return defaultNamespace
 }

internal/api/handler/iot_admin_stats_handler.go

@@ -1,4 +1,5 @@
 // Создано: 2026-04-06
+// Изменено: 2026-04-12 (замена Kafka lag → SQS queue stats)
 // iot_admin_stats_handler.go — handler для страницы администратора IoT.
 //
 // Endpoints:
@@ -6,8 +7,8 @@
 //
 // Источники данных:
 //   - PostgreSQL (IoTPG): counts per tenant, last 1h/24h, latest rows
-//   - Kafka: consumer lag (latest offset - committed offset для group iot-pg-consumer)
+//   - SQS: approximate message count (ApproximateNumberOfMessages)
-//   - K8s: статус подов iot-mqtt-bridge и iot-kafka-consumer
+//   - K8s: статус подов iot-mqtt-bridge и iot-sqs-consumer
 //
 // Авторизация: Bearer из env ADMIN_STATS_TOKEN.
 // Если ADMIN_STATS_TOKEN не задан — endpoint возвращает 503.
@@ -19,10 +20,14 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 
-	kafka "github.com/segmentio/kafka-go"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	corev1 "k8s.io/api/core/v1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -36,12 +41,11 @@ type iotAdminPodStatus struct {
 	Age      string `json:"age"`
 }
 
-// iotAdminKafkaStats — информация о Kafka топике и consumer lag.
+// iotAdminSQSStats — информация о SQS очереди для мониторинга.
-type iotAdminKafkaStats struct {
+type iotAdminSQSStats struct {
-	LatestOffset    int64  `json:"latest_offset"`
+	ApproximateMessages           int64  `json:"approximate_messages"`
-	CommittedOffset int64  `json:"committed_offset"`
+	ApproximateMessagesNotVisible int64  `json:"approximate_messages_not_visible"`
-	ConsumerLag     int64  `json:"consumer_lag"`
+	Error                         string `json:"error,omitempty"`
-	Error           string `json:"error,omitempty"`
 }
 
 // AdminStats обрабатывает GET /iot-admin/stats.
@@ -78,8 +82,8 @@ func (h *Handler) AdminStats(w http.ResponseWriter, r *http.Request) {
 		result["postgres"] = map[string]any{"reachable": false, "error": "IoTPG not configured"}
 	}
 
-	// Kafka: consumer lag для топика iot.telemetry / группы iot-pg-consumer
+	// SQS: approximate message count для очереди iot-telemetry
-	result["kafka"] = h.collectIotKafkaLag(ctx)
+	result["sqs"] = h.collectIotSQSStats(ctx)
 
 	// K8s: статус подов bridge и consumer
 	result["pods"] = h.collectIotPodStatuses(ctx)
@@ -87,72 +91,59 @@ func (h *Handler) AdminStats(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, result)
 }
 
-// collectIotKafkaLag получает latest offset топика и committed offset consumer group,
+// collectIotSQSStats получает ApproximateNumberOfMessages из SQS очереди.
-// вычисляет lag = latest - committed.
+// Использует SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY, SQS_QUEUE_NAME из env.
-// Topic: "iot.telemetry", Consumer Group: "iot-pg-consumer".
+func (h *Handler) collectIotSQSStats(ctx context.Context) iotAdminSQSStats {
-func (h *Handler) collectIotKafkaLag(ctx context.Context) iotAdminKafkaStats {
+	endpoint := os.Getenv("SQS_ENDPOINT")
-	if h.KafkaBrokers == "" {
+	accessKey := os.Getenv("SQS_ACCESS_KEY")
-		return iotAdminKafkaStats{Error: "KAFKA_BROKERS not configured"}
+	secretKey := os.Getenv("SQS_SECRET_KEY")
+	queueName := os.Getenv("SQS_QUEUE_NAME")
+	if queueName == "" {
+		queueName = "iot-telemetry"
+	}
+	region := os.Getenv("SQS_REGION")
+	if region == "" {
+		region = "us-east-1"
 	}
 
-	brokers := strings.Split(h.KafkaBrokers, ",")
+	if endpoint == "" || accessKey == "" || secretKey == "" {
-	brokerAddr := kafka.TCP(brokers...)
+		return iotAdminSQSStats{Error: "SQS credentials not configured (SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY)"}
-
-	kc := &kafka.Client{
-		Addr:    brokerAddr,
-		Timeout: 5 * time.Second,
 	}
 
-	const topic = "iot.telemetry"
+	sqsClient := sqs.New(sqs.Options{
-	const group = "iot-pg-consumer"
+		Region: region,
+		Credentials: credentials.NewStaticCredentialsProvider(
+			accessKey, secretKey, "",
+		),
+		BaseEndpoint: aws.String(endpoint),
+	})
 
-	// Получаем latest offset (конец лога — сколько всего сообщений прошло)
+	// Получаем URL очереди
-	offsetsResp, err := kc.ListOffsets(ctx, &kafka.ListOffsetsRequest{
+	queueUrlOut, err := sqsClient.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
-		Addr: brokerAddr,
+		QueueName: aws.String(queueName),
-		Topics: map[string][]kafka.OffsetRequest{
+	})
-			topic: {kafka.LastOffsetOf(0)},
+	if err != nil {
+		return iotAdminSQSStats{Error: fmt.Sprintf("GetQueueUrl: %v", err)}
+	}
+
+	// Запрашиваем атрибуты очереди — approximate message counts
+	attrsOut, err := sqsClient.GetQueueAttributes(ctx, &sqs.GetQueueAttributesInput{
+		QueueUrl: queueUrlOut.QueueUrl,
+		AttributeNames: []sqstypes.QueueAttributeName{
+			sqstypes.QueueAttributeNameApproximateNumberOfMessages,
+			sqstypes.QueueAttributeNameApproximateNumberOfMessagesNotVisible,
 		},
 	})
 	if err != nil {
-		return iotAdminKafkaStats{Error: fmt.Sprintf("list offsets: %v", err)}
+		return iotAdminSQSStats{Error: fmt.Sprintf("GetQueueAttributes: %v", err)}
 	}
 
-	var latestOffset int64
+	approxMsg, _ := strconv.ParseInt(attrsOut.Attributes["ApproximateNumberOfMessages"], 10, 64)
-	if partitions, ok := offsetsResp.Topics[topic]; ok && len(partitions) > 0 {
+	approxNotVisible, _ := strconv.ParseInt(attrsOut.Attributes["ApproximateNumberOfMessagesNotVisible"], 10, 64)
-		if partitions[0].Error == nil {
-			latestOffset = partitions[0].LastOffset
-		}
-	}
 
-	// Получаем committed offset consumer group (что consumer уже обработал)
+	return iotAdminSQSStats{
-	fetchResp, err := kc.OffsetFetch(ctx, &kafka.OffsetFetchRequest{
+		ApproximateMessages:           approxMsg,
-		Addr:    brokerAddr,
+		ApproximateMessagesNotVisible: approxNotVisible,
-		GroupID: group,
-		Topics:  map[string][]int{topic: {0}},
-	})
-	if err != nil {
-		return iotAdminKafkaStats{
-			LatestOffset: latestOffset,
-			Error:        fmt.Sprintf("offset fetch: %v", err),
-		}
-	}
-
-	var committedOffset int64
-	if partitions, ok := fetchResp.Topics[topic]; ok && len(partitions) > 0 {
-		if partitions[0].Error == nil {
-			committedOffset = partitions[0].CommittedOffset
-		}
-	}
-
-	lag := latestOffset - committedOffset
-	if lag < 0 {
-		lag = 0
-	}
-
-	return iotAdminKafkaStats{
-		LatestOffset:    latestOffset,
-		CommittedOffset: committedOffset,
-		ConsumerLag:     lag,
 	}
 }
 
@@ -160,7 +151,7 @@ func (h *Handler) collectIotKafkaLag(ctx context.Context) iotAdminKafkaStats {
 func (h *Handler) collectIotPodStatuses(ctx context.Context) map[string]any {
 	result := map[string]any{}
 
-	for _, appLabel := range []string{"iot-mqtt-bridge", "iot-kafka-consumer"} {
+	for _, appLabel := range []string{"iot-mqtt-bridge", "iot-sqs-consumer"} {
 		podList := &corev1.PodList{}
 		if err := h.K8s.List(ctx, podList,
 			client.InNamespace("sless"),

internal/api/handler/iot_device_handler.go

@@ -151,6 +151,18 @@ func (h *Handler) MQTTAuth(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+
+	// Bridge — внутренний MQTT bridge клиент. Проверяем фиксированные credentials
+	// до парсинга namespace_deviceId.
+	if h.BridgeUsername != "" && req.Username == h.BridgeUsername {
+		if subtle.ConstantTimeCompare([]byte(h.BridgePassword), []byte(req.Password)) == 1 {
+			writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "allow"})
+			return
+		}
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+
 	// Парсим username: "{namespace}_{deviceId}"
 	// Namespace содержит только [a-z0-9-], первый "_" — разделитель.
 	idx := strings.Index(req.Username, "_")
@@ -181,10 +193,21 @@ func (h *Handler) MQTTAuth(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Проверяем что IoTDevice активно
+	// Ищем IoTDevice по Spec.DeviceID (имя K8s объекта может отличаться от deviceID)
-	device := &iotv1alpha1.IoTDevice{}
+	deviceList := &iotv1alpha1.IoTDeviceList{}
-	if err := h.K8s.Get(r.Context(), client.ObjectKey{Namespace: ns, Name: deviceID}, device); err != nil {
+	if err := h.K8s.List(r.Context(), deviceList, client.InNamespace(ns)); err != nil {
-		// IoTDevice не найден (или удалён) — deny
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+	var device *iotv1alpha1.IoTDevice
+	for i := range deviceList.Items {
+		if deviceList.Items[i].Spec.DeviceID == deviceID {
+			device = &deviceList.Items[i]
+			break
+		}
+	}
+	if device == nil {
+		// IoTDevice с таким deviceID не найден — deny
 		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
 		return
 	}
@@ -427,6 +450,9 @@ func (h *Handler) MQTTAcl(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+
+	// Bridge — внутренний MQTT bridge клиент. Проверяем фиксированные credentials
+	// до парсинга namespace_deviceId.
 	// Парсим username → namespace + deviceId (формат: "{ns}_{deviceId}")
 	// strings.Index находит ПЕРВЫЙ '_' — namespace содержит только дефисы
 	idx := strings.Index(req.Username, "_")

internal/api/handler/iot_telemetry_handler.go

@@ -28,7 +28,7 @@ func (h *Handler) ListIoTTelemetry(w http.ResponseWriter, r *http.Request) {
 	}
 
 	ns := mux.Vars(r)["namespace"]
-	deviceID := r.URL.Query().Get("device")
+	deviceID := r.URL.Query().Get("device_id")
 	limit := 50
 	if ls := r.URL.Query().Get("limit"); ls != "" {
 		if n, err := strconv.Atoi(ls); err == nil && n > 0 {
@@ -36,7 +36,7 @@ func (h *Handler) ListIoTTelemetry(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	rows, err := h.IoTPG.QueryTelemetry(r.Context(), ns, deviceID, limit)
+	rows, err := h.IoTPG.QueryTelemetry(r.Context(), ns, deviceID, limit, 0)
 	if err != nil {
 		h.Log.Error("query IoT telemetry", "namespace", ns, "device", deviceID, "err", err)
 		writeJSON(w, http.StatusInternalServerError, errResp("failed to query telemetry"))

internal/service/api/admin_embed.go

@@ -0,0 +1,20 @@
+// admin_embed.go — встраивает HTML страницы администратора в бинарник.
+package api
+
+import (
+	_ "embed"
+	"net/http"
+)
+
+// iotAdminHTML — страница /iot-admin, встроена при сборке.
+//
+//go:embed ui/iot-admin.html
+var iotAdminHTML []byte
+
+// ServeIoTAdmin отдаёт HTML страницу администратора.
+func ServeIoTAdmin(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Header().Set("Cache-Control", "no-cache, must-revalidate")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(iotAdminHTML)
+}

internal/service/api/console_embed.go

@@ -0,0 +1,20 @@
+// console_embed.go — встраивает HTML IoT консоли в бинарник.
+package api
+
+import (
+	_ "embed"
+	"net/http"
+)
+
+// iotConsoleHTML — консоль /console, встроена при сборке.
+//
+//go:embed ui/iot-console.html
+var iotConsoleHTML []byte
+
+// ServeIoTConsole отдаёт HTML консоли.
+func ServeIoTConsole(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Header().Set("Cache-Control", "no-cache, must-revalidate")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(iotConsoleHTML)
+}

internal/service/api/handler/admin.go

@@ -0,0 +1,58 @@
+// admin.go — статистика для страницы администратора.
+//
+// Endpoint: GET /iot-admin/stats (Bearer ADMIN_STATS_TOKEN).
+// Источники: PostgreSQL (iotpg), shared-SQS (атрибуты очереди), рантайм процесса.
+// k8s-статусы подов убраны — компоненты теперь в одном процессе.
+package handler
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// AdminStats — GET /iot-admin/stats.
+func (h *Handler) AdminStats(w http.ResponseWriter, r *http.Request) {
+	if h.Cfg.AdminStatsToken == "" {
+		writeJSON(w, http.StatusServiceUnavailable, errResp("admin stats not configured: ADMIN_STATS_TOKEN not set"))
+		return
+	}
+
+	authHeader := r.Header.Get("Authorization")
+	if !strings.HasPrefix(authHeader, "Bearer ") || strings.TrimPrefix(authHeader, "Bearer ") != h.Cfg.AdminStatsToken {
+		writeJSON(w, http.StatusUnauthorized, errResp("unauthorized"))
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
+	defer cancel()
+
+	result := map[string]any{
+		"collected_at": time.Now().UTC(),
+	}
+
+	// PostgreSQL: статистика по всем tenant (как в старом коде).
+	if h.IoTPG != nil {
+		pgStats, err := h.IoTPG.GetAdminStats(ctx)
+		if err != nil {
+			result["postgres"] = map[string]any{"reachable": false, "error": err.Error()}
+		} else {
+			result["postgres"] = pgStats
+		}
+	} else {
+		result["postgres"] = map[string]any{"reachable": false, "error": "IoTPG not configured"}
+	}
+
+	// SQS: approximate counts очереди телеметрии.
+	result["sqs"] = h.collectSQSStats(ctx)
+
+	// Рантайм процесса (вместо статусов k8s-подов).
+	result["runtime"] = map[string]any{
+		"version":    h.Version,
+		"uptime_sec": int64(time.Since(h.StartedAt).Seconds()),
+		"started_at": h.StartedAt.UTC().Format(time.RFC3339),
+	}
+
+	writeJSON(w, http.StatusOK, result)
+}

internal/service/api/handler/devices.go

@@ -0,0 +1,256 @@
+// devices.go — CRUD устройств на PostgreSQL.
+//
+// Endpoints:
+//
+//	POST   /v1/namespaces/{ns}/iot/devices        — создать
+//	GET    /v1/namespaces/{ns}/iot/devices        — список (без паролей)
+//	GET    /v1/namespaces/{ns}/iot/devices/{name} — одно (с паролем)
+//	DELETE /v1/namespaces/{ns}/iot/devices/{name} — удалить
+//	PATCH  /v1/namespaces/{ns}/iot/devices/{name} — enabled
+package handler
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strconv"
+	"time"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/store"
+)
+
+// iotDeviceCreateRequest — тело POST.
+type iotDeviceCreateRequest struct {
+	Name     string            `json:"name"`
+	DeviceID string            `json:"device_id"`
+	Enabled  *bool             `json:"enabled"`
+	Metadata map[string]string `json:"metadata,omitempty"`
+}
+
+// iotDeviceUpdateRequest — тело PATCH.
+type iotDeviceUpdateRequest struct {
+	Enabled *bool `json:"enabled"`
+}
+
+// iotDeviceResponse — ответ API. MQTTPassword — только в GET по имени.
+type iotDeviceResponse struct {
+	Name          string            `json:"name"`
+	Namespace     string            `json:"namespace"`
+	DeviceID      string            `json:"device_id"`
+	Enabled       bool              `json:"enabled"`
+	Phase         string            `json:"phase"`
+	MQTTUsername  string            `json:"mqtt_username,omitempty"`
+	MQTTPassword  string            `json:"mqtt_password,omitempty"`
+	TopicPrefix   string            `json:"topic_prefix,omitempty"`
+	LastConnected string            `json:"last_connected,omitempty"`
+	Metadata      map[string]string `json:"metadata,omitempty"`
+	CreatedAt     string            `json:"created_at,omitempty"`
+}
+
+// deviceToResponse конвертирует устройство из БД в ответ API.
+// password отдаётся только если непустая (передаётся явно из Get).
+func deviceToResponse(d *store.Device, password string) iotDeviceResponse {
+	resp := iotDeviceResponse{
+		Name:         d.Name,
+		Namespace:    d.Namespace,
+		DeviceID:     d.DeviceID,
+		Enabled:      d.Enabled,
+		Phase:        d.Phase,
+		MQTTUsername: d.Namespace + "_" + d.DeviceID,
+		MQTTPassword: password,
+		TopicPrefix:  d.Namespace + "/",
+		Metadata:     d.Metadata,
+	}
+	if d.LastConnected != nil && !d.LastConnected.IsZero() {
+		resp.LastConnected = d.LastConnected.UTC().Format(time.RFC3339)
+	}
+	if !d.CreatedAt.IsZero() {
+		resp.CreatedAt = d.CreatedAt.UTC().Format("2006-01-02 15:04:05 UTC")
+	}
+	return resp
+}
+
+// generateMQTTPassword — 32 случайных байта в hex (как старый контроллер).
+// crypto/rand ошибку даёт только при сбое системного PRNG — 3 попытки
+// (ревью 2026-08-16: не возвращать пустой пароль).
+func generateMQTTPassword() (string, error) {
+	var lastErr error
+	for attempt := 0; attempt < 3; attempt++ {
+		buf := make([]byte, 32)
+		if _, err := rand.Read(buf); err == nil {
+			return hex.EncodeToString(buf), nil
+		} else {
+			lastErr = err
+		}
+	}
+	return "", lastErr
+}
+
+// CreateIoTDevice — POST /v1/namespaces/{ns}/iot/devices.
+func (h *Handler) CreateIoTDevice(w http.ResponseWriter, r *http.Request) {
+	ns := pathVar(r, "namespace")
+	if ns == "" {
+		ns = "default"
+	}
+
+	var req iotDeviceCreateRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSON(w, http.StatusBadRequest, errResp("invalid JSON: "+err.Error()))
+		return
+	}
+	if req.Name == "" {
+		writeJSON(w, http.StatusBadRequest, errResp("name is required"))
+		return
+	}
+	if req.DeviceID == "" {
+		writeJSON(w, http.StatusBadRequest, errResp("device_id is required"))
+		return
+	}
+
+	enabled := true
+	if req.Enabled != nil {
+		enabled = *req.Enabled
+	}
+
+	password, err := generateMQTTPassword()
+	if err != nil {
+		h.Log.Error("generate device password", "err", err)
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to generate credentials"))
+		return
+	}
+
+	phase := "Active"
+	if !enabled {
+		phase = "Disabled"
+	}
+
+	device := &store.Device{
+		Namespace:    ns,
+		Name:         req.Name,
+		DeviceID:     req.DeviceID,
+		Enabled:      enabled,
+		MQTTPassword: password,
+		Metadata:     req.Metadata,
+		Phase:        phase,
+	}
+
+	if err := h.Devices.Create(r.Context(), device); err != nil {
+		if errors.Is(err, store.ErrAlreadyExists) {
+			writeJSON(w, http.StatusConflict, errResp("iot device already exists"))
+			return
+		}
+		h.Log.Error("create device", "namespace", ns, "name", req.Name, "err", err)
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to create device"))
+		return
+	}
+
+	writeJSON(w, http.StatusCreated, deviceToResponse(device, ""))
+}
+
+// ListIoTDevices — GET /v1/namespaces/{ns}/iot/devices (без паролей).
+// Пагинация: ?limit=N&offset=M (0 = без ограничения).
+func (h *Handler) ListIoTDevices(w http.ResponseWriter, r *http.Request) {
+	ns := pathVar(r, "namespace")
+	if ns == "" {
+		ns = "default"
+	}
+
+	limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
+	offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
+
+	devices, err := h.Devices.List(r.Context(), ns, limit, offset)
+	if err != nil {
+		h.Log.Error("list devices", "namespace", ns, "err", err)
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to list devices"))
+		return
+	}
+
+	result := make([]iotDeviceResponse, 0, len(devices))
+	for i := range devices {
+		result = append(result, deviceToResponse(&devices[i], ""))
+	}
+	writeJSON(w, http.StatusOK, result)
+}
+
+// GetIoTDevice — GET /v1/namespaces/{ns}/iot/devices/{name} (с паролем).
+func (h *Handler) GetIoTDevice(w http.ResponseWriter, r *http.Request) {
+	ns := pathVar(r, "namespace")
+	if ns == "" {
+		ns = "default"
+	}
+	name := pathVar(r, "name")
+
+	device, err := h.Devices.GetByName(r.Context(), ns, name)
+	if err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			writeJSON(w, http.StatusNotFound, errResp("iot device not found"))
+			return
+		}
+		h.Log.Error("get device", "namespace", ns, "name", name, "err", err)
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to get device"))
+		return
+	}
+
+	writeJSON(w, http.StatusOK, deviceToResponse(device, device.MQTTPassword))
+}
+
+// DeleteIoTDevice — DELETE /v1/namespaces/{ns}/iot/devices/{name}.
+func (h *Handler) DeleteIoTDevice(w http.ResponseWriter, r *http.Request) {
+	ns := pathVar(r, "namespace")
+	if ns == "" {
+		ns = "default"
+	}
+	name := pathVar(r, "name")
+
+	err := h.Devices.Delete(r.Context(), ns, name)
+	if err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			writeJSON(w, http.StatusNotFound, errResp("iot device not found"))
+			return
+		}
+		h.Log.Error("delete device", "namespace", ns, "name", name, "err", err)
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to delete device"))
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// UpdateIoTDevice — PATCH /v1/namespaces/{ns}/iot/devices/{name} (enabled).
+func (h *Handler) UpdateIoTDevice(w http.ResponseWriter, r *http.Request) {
+	ns := pathVar(r, "namespace")
+	if ns == "" {
+		ns = "default"
+	}
+	name := pathVar(r, "name")
+
+	var req iotDeviceUpdateRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSON(w, http.StatusBadRequest, errResp("invalid JSON: "+err.Error()))
+		return
+	}
+	if req.Enabled == nil {
+		writeJSON(w, http.StatusBadRequest, errResp("enabled field is required"))
+		return
+	}
+
+	err := h.Devices.UpdateEnabled(r.Context(), ns, name, *req.Enabled)
+	if err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			writeJSON(w, http.StatusNotFound, errResp("iot device not found"))
+			return
+		}
+		h.Log.Error("update device", "namespace", ns, "name", name, "err", err)
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to update device"))
+		return
+	}
+
+	device, err := h.Devices.GetByName(r.Context(), ns, name)
+	if err != nil {
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to reload device"))
+		return
+	}
+	writeJSON(w, http.StatusOK, deviceToResponse(device, ""))
+}

internal/service/api/handler/handler.go

@@ -0,0 +1,49 @@
+// Package handler — HTTP-обработчики IoT REST API (новый монолит).
+//
+// Отличие от старого кода: устройства — в PostgreSQL (таблица iot_devices),
+// без k8s-клиента и CRD. Телеметрия — через iotpg, как раньше.
+package handler
+
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	"github.com/gorilla/mux"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/config"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/store"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+)
+
+// Handler — зависимости всех HTTP-обработчиков.
+type Handler struct {
+	Devices *store.DeviceStore
+	IoTPG   *iotpg.IoTPostgresStore
+	SQS     *sqs.Client
+	Cfg     *config.Config
+	Log     *slog.Logger
+
+	// Version — версия бинарника (ldflags), StartedAt — для админ-статистики.
+	Version   string
+	StartedAt time.Time
+}
+
+// writeJSON отправляет JSON-ответ с указанным статусом.
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}
+
+// errResp возвращает структуру ошибки для JSON.
+func errResp(msg string) map[string]string {
+	return map[string]string{"error": msg}
+}
+
+// pathVar читает переменную пути из gorilla/mux.
+func pathVar(r *http.Request, key string) string {
+	return mux.Vars(r)[key]
+}

internal/service/api/handler/mqtt_auth.go

@@ -0,0 +1,167 @@
+// mqtt_auth.go — HTTP-auth и ACL для EMQX (MQTT CONNECT / pub-sub).
+//
+// Endpoints (без JWT, вызываются EMQX внутри платформы):
+//
+//	POST /internal/mqtt/auth — аутентификация: всегда HTTP 200, {"result":"allow"|"deny"}
+//	POST /internal/mqtt/acl  — авторизация pub/sub
+//
+// Источник устройств — таблица iot_devices (не k8s Secrets).
+package handler
+
+import (
+	"crypto/subtle"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strings"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/store"
+)
+
+// mqttAuthRequest — тело запроса от EMQX 5.x (username, password, clientid, peerhost).
+type mqttAuthRequest struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+	ClientID string `json:"clientid"`
+	PeerHost string `json:"peerhost"`
+}
+
+// mqttAuthResponse — ответ для EMQX (всегда HTTP 200).
+type mqttAuthResponse struct {
+	Result string    `json:"result"`
+	ACL    []aclRule `json:"acl,omitempty"`
+}
+
+// aclRule — правило ACL для EMQX HTTP auth.
+type aclRule struct {
+	Permission string `json:"permission"`
+	Action     string `json:"action"`
+	Topic      string `json:"topic"`
+}
+
+// mqttAclRequest — тело запроса ACL от EMQX.
+type mqttAclRequest struct {
+	Username string `json:"username"`
+	ClientID string `json:"clientid"`
+	Action   string `json:"action"`
+	Topic    string `json:"topic"`
+}
+
+// MQTTAuth — POST /internal/mqtt/auth.
+//
+// Логика:
+//  1. bridge-креды (MQTT_USERNAME/MQTT_PASSWORD из env) — проверяются до парсинга;
+//  2. username "{ns}_{deviceId}" → поиск устройства в iot_devices;
+//  3. constant-time сравнение пароля; проверка enabled;
+//  4. best-effort last_connected; ACL по топику устройства.
+func (h *Handler) MQTTAuth(w http.ResponseWriter, r *http.Request) {
+	var req mqttAuthRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+
+	// Внутренний bridge-клиент: фиксированные креды, ACL выдаётся ниже.
+	if h.Cfg.MQTTUsername != "" && req.Username == h.Cfg.MQTTUsername {
+		if subtle.ConstantTimeCompare([]byte(h.Cfg.MQTTPassword), []byte(req.Password)) == 1 {
+			writeJSON(w, http.StatusOK, mqttAuthResponse{
+				Result: "allow",
+				ACL:    bridgeACLRules(),
+			})
+			return
+		}
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+
+	// Парсим username: "{namespace}_{deviceId}" (первый '_' — разделитель).
+	idx := strings.Index(req.Username, "_")
+	if idx <= 0 || idx == len(req.Username)-1 {
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+	ns := req.Username[:idx]
+	deviceID := req.Username[idx+1:]
+
+	device, err := h.Devices.GetByDeviceID(r.Context(), ns, deviceID)
+	if err != nil {
+		if !errors.Is(err, store.ErrNotFound) {
+			h.Log.Error("mqtt auth: device lookup", "namespace", ns, "device", deviceID, "err", err)
+		}
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+	if !device.Enabled {
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+	if subtle.ConstantTimeCompare([]byte(device.MQTTPassword), []byte(req.Password)) != 1 {
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+
+	// best-effort: обновляем время последнего подключения
+	h.Devices.TouchLastConnected(r.Context(), ns, deviceID)
+
+	writeJSON(w, http.StatusOK, mqttAuthResponse{
+		Result: "allow",
+		ACL:    deviceACLRules(ns, deviceID),
+	})
+}
+
+// MQTTAcl — POST /internal/mqtt/acl.
+//
+// Bridge (clientID из env MQTT_CLIENT_ID): только subscribe.
+// Устройство ({ns}_{deviceId}): pub/sub в своём топике.
+func (h *Handler) MQTTAcl(w http.ResponseWriter, r *http.Request) {
+	var req mqttAclRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+
+	if req.ClientID == h.Cfg.MQTTClientID {
+		if req.Action == "subscribe" {
+			writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "allow"})
+			return
+		}
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+
+	idx := strings.Index(req.Username, "_")
+	if idx <= 0 || idx == len(req.Username)-1 {
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+		return
+	}
+	ns := req.Username[:idx]
+	deviceID := req.Username[idx+1:]
+	deviceTopic := ns + "/telemetry/" + deviceID
+
+	switch {
+	case req.Action == "publish" && req.Topic == deviceTopic:
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "allow"})
+	case req.Action == "subscribe" && (req.Topic == deviceTopic || req.Topic == "#"):
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "allow"})
+	default:
+		writeJSON(w, http.StatusOK, mqttAuthResponse{Result: "deny"})
+	}
+}
+
+// bridgeACLRules — ACL для внутреннего bridge: subscribe на все telemetry-топики.
+func bridgeACLRules() []aclRule {
+	return []aclRule{
+		{Permission: "allow", Action: "subscribe", Topic: "+/telemetry/+"},
+		{Permission: "deny", Action: "all", Topic: "#"},
+	}
+}
+
+// deviceACLRules — ACL для устройства: только свой топик телеметрии.
+func deviceACLRules(ns, deviceID string) []aclRule {
+	topic := ns + "/telemetry/" + deviceID
+	return []aclRule{
+		{Permission: "allow", Action: "publish", Topic: topic},
+		{Permission: "allow", Action: "subscribe", Topic: topic},
+		{Permission: "deny", Action: "all", Topic: "#"},
+	}
+}

internal/service/api/handler/sqsstats.go

@@ -0,0 +1,52 @@
+// sqsstats.go — сбор статистики очереди shared-SQS для админ-страницы.
+package handler
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
+)
+
+// iotAdminSQSStats — информация об очереди для мониторинга.
+type iotAdminSQSStats struct {
+	ApproximateMessages           int64  `json:"approximate_messages"`
+	ApproximateMessagesNotVisible int64  `json:"approximate_messages_not_visible"`
+	Error                         string `json:"error,omitempty"`
+}
+
+// collectSQSStats получает ApproximateNumberOfMessages из очереди телеметрии.
+func (h *Handler) collectSQSStats(ctx context.Context) iotAdminSQSStats {
+	if h.SQS == nil {
+		return iotAdminSQSStats{Error: "SQS client not configured"}
+	}
+
+	queueUrlOut, err := h.SQS.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
+		QueueName: aws.String(h.Cfg.SQSQueueName),
+	})
+	if err != nil {
+		return iotAdminSQSStats{Error: fmt.Sprintf("GetQueueUrl: %v", err)}
+	}
+
+	attrsOut, err := h.SQS.GetQueueAttributes(ctx, &sqs.GetQueueAttributesInput{
+		QueueUrl: queueUrlOut.QueueUrl,
+		AttributeNames: []sqstypes.QueueAttributeName{
+			sqstypes.QueueAttributeNameApproximateNumberOfMessages,
+			sqstypes.QueueAttributeNameApproximateNumberOfMessagesNotVisible,
+		},
+	})
+	if err != nil {
+		return iotAdminSQSStats{Error: fmt.Sprintf("GetQueueAttributes: %v", err)}
+	}
+
+	approxMsg, _ := strconv.ParseInt(attrsOut.Attributes["ApproximateNumberOfMessages"], 10, 64)
+	approxNotVisible, _ := strconv.ParseInt(attrsOut.Attributes["ApproximateNumberOfMessagesNotVisible"], 10, 64)
+
+	return iotAdminSQSStats{
+		ApproximateMessages:           approxMsg,
+		ApproximateMessagesNotVisible: approxNotVisible,
+	}
+}

internal/service/api/handler/telemetry.go

@@ -0,0 +1,49 @@
+// telemetry.go — REST-чтение телеметрии из per-tenant PostgreSQL.
+//
+// Endpoint: GET /v1/namespaces/{ns}/iot/telemetry?device_id={id}&limit={n}
+package handler
+
+import (
+	"net/http"
+	"strconv"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+)
+
+// ListIoTTelemetry — GET /v1/namespaces/{ns}/iot/telemetry.
+func (h *Handler) ListIoTTelemetry(w http.ResponseWriter, r *http.Request) {
+	if h.IoTPG == nil {
+		writeJSON(w, http.StatusServiceUnavailable, errResp("IoT telemetry storage not configured"))
+		return
+	}
+
+	ns := pathVar(r, "namespace")
+	deviceID := r.URL.Query().Get("device_id")
+	limit := 50
+	if ls := r.URL.Query().Get("limit"); ls != "" {
+		if n, err := strconv.Atoi(ls); err == nil && n > 0 {
+			limit = n
+		}
+	}
+	offset := 0
+	if os := r.URL.Query().Get("offset"); os != "" {
+		if n, err := strconv.Atoi(os); err == nil && n >= 0 {
+			offset = n
+		}
+	}
+
+	rows, err := h.IoTPG.QueryTelemetry(r.Context(), ns, deviceID, limit, offset)
+	if err != nil {
+		h.Log.Error("query IoT telemetry", "namespace", ns, "device", deviceID, "err", err)
+		writeJSON(w, http.StatusInternalServerError, errResp("failed to query telemetry"))
+		return
+	}
+	if rows == nil {
+		rows = []iotpg.TelemetryRow{}
+	}
+
+	writeJSON(w, http.StatusOK, map[string]any{
+		"items": rows,
+		"count": len(rows),
+	})
+}

internal/service/api/landing_embed.go

@@ -0,0 +1,40 @@
+// landing_embed.go — встраивает лендинг-инструкцию и статику (лого, favicon).
+package api
+
+import (
+	"embed"
+	"io/fs"
+	"net/http"
+	"strings"
+)
+
+// landingHTML — лендинг "/" с инструкцией (дизайн shared-sqs).
+//
+//go:embed ui/landing.html
+var landingHTML []byte
+
+// staticFS — логотип и favicon (дизайн Nubes, как на shared-sqs).
+//
+//go:embed ui/static
+var staticFS embed.FS
+
+// versionPlaceholder — заменяется на версию при отдаче страницы.
+const versionPlaceholder = "{{VERSION}}"
+
+// ServeLanding отдаёт лендинг "/" с подставленной версией.
+func ServeLanding(w http.ResponseWriter, r *http.Request, version string) {
+	body := strings.ReplaceAll(string(landingHTML), versionPlaceholder, version)
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Header().Set("Cache-Control", "no-cache, must-revalidate")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write([]byte(body))
+}
+
+// StaticHandler раздаёт /static/* (logo.svg, favicon.svg) из embed.
+func StaticHandler() http.Handler {
+	sub, err := fs.Sub(staticFS, "ui/static")
+	if err != nil {
+		panic(err)
+	}
+	return http.FileServer(http.FS(sub))
+}

internal/service/api/middleware/auth.go

@@ -0,0 +1,126 @@
+// Package middleware — HTTP-промежуточные слои API.
+package middleware
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"log/slog"
+	"net/http"
+	"strings"
+)
+
+// Auth — проверка Bearer-токена.
+//
+// authTestMode (env AUTH_TEST_MODE, дефолт false):
+//   - true  — принимается любая строка без пробелов (для локальных тестов);
+//   - false — проверка JWT: sub + exp; если задан hmacSecret — обязательна
+//     HS256-подпись (HMAC-SHA256, env JWT_HMAC_SECRET). Без секрета —
+//     структурная проверка (периметр обеспечивает платформа).
+func Auth(authTestMode bool, hmacSecret string, log *slog.Logger, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		header := r.Header.Get("Authorization")
+		if header == "" {
+			log.Warn("auth: missing authorization header", "remote", r.RemoteAddr, "path", r.URL.Path)
+			http.Error(w, `{"error":"authorization required"}`, http.StatusUnauthorized)
+			return
+		}
+		parts := strings.SplitN(header, " ", 2)
+		if len(parts) != 2 || !strings.EqualFold(parts[0], "bearer") {
+			log.Warn("auth: invalid authorization format", "remote", r.RemoteAddr)
+			http.Error(w, `{"error":"invalid authorization format, use Bearer <token>"}`, http.StatusUnauthorized)
+			return
+		}
+		token := parts[1]
+
+		if authTestMode && isPlainToken(token) {
+			log.Info("auth: test mode — plain token accepted", "remote", r.RemoteAddr, "path", r.URL.Path)
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		if err := validateJWT(token, hmacSecret); err != nil {
+			log.Warn("auth: invalid token", "remote", r.RemoteAddr, "path", r.URL.Path, "reason", err.Error())
+			http.Error(w, `{"error":"invalid token"}`, http.StatusForbidden)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// isPlainToken — непустая строка без пробелов, не похожая на JWT (три части через точку).
+func isPlainToken(token string) bool {
+	if token == "" || strings.ContainsAny(token, " \t\n\r") {
+		return false
+	}
+	return len(strings.Split(token, ".")) != 3
+}
+
+// jwtError — структурная ошибка JWT.
+type jwtError struct{ msg string }
+
+func (e *jwtError) Error() string { return e.msg }
+
+// validateJWT проверяет структуру JWT (sub + exp) и, если задан secret,
+// HS256-подпись. Без secret подпись не проверяется — см. комментарий Auth.
+func validateJWT(token, secret string) error {
+	jwtParts := strings.Split(token, ".")
+	if len(jwtParts) != 3 {
+		return &jwtError{"not a JWT: expected 3 parts"}
+	}
+
+	if secret != "" {
+		var header struct {
+			Alg string `json:"alg"`
+		}
+		headerBytes, err := base64.RawURLEncoding.DecodeString(jwtParts[0])
+		if err != nil {
+			headerBytes, err = base64.StdEncoding.DecodeString(jwtParts[0])
+		}
+		if err != nil || jsonUnmarshal(headerBytes, &header) != nil || header.Alg != "HS256" {
+			return &jwtError{"JWT must be HS256 when JWT_HMAC_SECRET is set"}
+		}
+		mac := hmac.New(sha256.New, []byte(secret))
+		mac.Write([]byte(jwtParts[0] + "." + jwtParts[1]))
+		expected := mac.Sum(nil)
+		sig, err := base64.RawURLEncoding.DecodeString(jwtParts[2])
+		if err != nil {
+			return &jwtError{"cannot decode JWT signature"}
+		}
+		if !hmac.Equal(expected, sig) {
+			return &jwtError{"JWT signature mismatch"}
+		}
+	}
+
+	payload := jwtParts[1]
+	switch len(payload) % 4 {
+	case 2:
+		payload += "=="
+	case 3:
+		payload += "="
+	}
+	decoded, err := base64.URLEncoding.DecodeString(payload)
+	if err != nil {
+		decoded, err = base64.StdEncoding.DecodeString(payload)
+	}
+	if err != nil {
+		return &jwtError{"cannot decode JWT payload"}
+	}
+
+	var claims struct {
+		Sub string  `json:"sub"`
+		Exp float64 `json:"exp"`
+	}
+	if err := jsonUnmarshal(decoded, &claims); err != nil {
+		return &jwtError{"cannot parse JWT payload"}
+	}
+	if claims.Sub == "" {
+		return &jwtError{"JWT missing sub claim"}
+	}
+	if claims.Exp > 0 {
+		if now := float64(timeNow().Unix()); claims.Exp < now {
+			return &jwtError{"JWT expired"}
+		}
+	}
+	return nil
+}

internal/service/api/middleware/auth_helpers.go

@@ -0,0 +1,15 @@
+package middleware
+
+import (
+	"encoding/json"
+	"time"
+)
+
+// jsonUnmarshal и timeNow вынесены для простоты тестирования.
+func jsonUnmarshal(data []byte, v any) error {
+	return json.Unmarshal(data, v)
+}
+
+func timeNow() time.Time {
+	return time.Now()
+}

internal/service/api/middleware/logging.go

@@ -0,0 +1,35 @@
+// Package middleware — HTTP-промежуточные слои API.
+package middleware
+
+import (
+	"log/slog"
+	"net/http"
+	"time"
+)
+
+// responseWriter перехватывает статус ответа для логирования.
+type responseWriter struct {
+	http.ResponseWriter
+	status int
+}
+
+func (rw *responseWriter) WriteHeader(code int) {
+	rw.status = code
+	rw.ResponseWriter.WriteHeader(code)
+}
+
+// Logging логирует каждый HTTP-запрос: метод, путь, статус, длительность.
+func Logging(log *slog.Logger, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+		rw := &responseWriter{ResponseWriter: w, status: http.StatusOK}
+		next.ServeHTTP(rw, r)
+		log.Info("http",
+			"method", r.Method,
+			"path", r.URL.Path,
+			"status", rw.status,
+			"duration_ms", time.Since(start).Milliseconds(),
+			"remote", r.RemoteAddr,
+		)
+	})
+}

internal/service/api/router.go

@@ -0,0 +1,76 @@
+// Package api — HTTP-сервер монолита: маршруты, CORS, health.
+package api
+
+import (
+	"log/slog"
+	"net/http"
+
+	"github.com/gorilla/mux"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/api/handler"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/api/middleware"
+)
+
+// corsMiddleware добавляет CORS-заголовки (консоль и API на одном домене платформы).
+func corsMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// NewRouter собирает все маршруты сервиса.
+func NewRouter(h *handler.Handler, log *slog.Logger, authTestMode bool, jwtHMACSecret string, version string) http.Handler {
+	r := mux.NewRouter()
+
+	// Health — для платформенных проверок контейнера.
+	r.HandleFunc("/health", healthHandler(version)).Methods(http.MethodGet)
+	r.HandleFunc("/healthz", healthHandler(version)).Methods(http.MethodGet)
+
+	// Лендинг "/" — инструкция (дизайн Nubes, как у shared-sqs) + статика.
+	r.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+		ServeLanding(w, req, version)
+	}).Methods(http.MethodGet)
+	r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", StaticHandler()))
+
+	// UI — публичные страницы (без данных).
+	r.HandleFunc("/console", ServeIoTConsole).Methods(http.MethodGet)
+	r.HandleFunc("/iot-admin", ServeIoTAdmin).Methods(http.MethodGet)
+
+	// Админ-статистика — свой Bearer-токен.
+	r.HandleFunc("/iot-admin/stats", h.AdminStats).Methods(http.MethodGet)
+
+	// MQTT auth/acl — для EMQX, без JWT.
+	r.HandleFunc("/internal/mqtt/auth", h.MQTTAuth).Methods(http.MethodPost)
+	r.HandleFunc("/internal/mqtt/acl", h.MQTTAcl).Methods(http.MethodPost)
+
+	// /v1 — под JWT.
+	v1 := r.PathPrefix("/v1").Subrouter()
+	v1.HandleFunc("/namespaces/{namespace}/iot/devices", h.ListIoTDevices).Methods(http.MethodGet)
+	v1.HandleFunc("/namespaces/{namespace}/iot/devices", h.CreateIoTDevice).Methods(http.MethodPost)
+	v1.HandleFunc("/namespaces/{namespace}/iot/devices/{name}", h.GetIoTDevice).Methods(http.MethodGet)
+	v1.HandleFunc("/namespaces/{namespace}/iot/devices/{name}", h.DeleteIoTDevice).Methods(http.MethodDelete)
+	v1.HandleFunc("/namespaces/{namespace}/iot/devices/{name}", h.UpdateIoTDevice).Methods(http.MethodPatch)
+	v1.HandleFunc("/namespaces/{namespace}/iot/telemetry", h.ListIoTTelemetry).Methods(http.MethodGet)
+
+	v1.Use(func(next http.Handler) http.Handler {
+		return middleware.Auth(authTestMode, jwtHMACSecret, log, next)
+	})
+
+	return corsMiddleware(middleware.Logging(log, r))
+}
+
+// healthHandler отдаёт статус сервиса и версию (для платформы).
+func healthHandler(version string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"status":"ok","version":"` + version + `"}`))
+	}
+}

internal/service/api/ui/iot-admin.html

@@ -0,0 +1,548 @@
+<!DOCTYPE html>
+<!-- Создано: 2026-04-06
+     iot-admin.html — страница администратора IoT pipeline.
+     Показывает: PostgreSQL stats per tenant, Kafka consumer lag, K8s pod statuses.
+     Auth: ADMIN_STATS_TOKEN вводится вручную и хранится в sessionStorage.
+     Раздаётся по GET /iot-admin (go:embed в бинарнике оператора).
+     НЕ для конечных пользователей — только для администратора платформы. -->
+<html lang="ru">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Nubes IoT Admin</title>
+  <link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+  <link rel="icon" href="https://terra.k8c.ru/docs/nubes/nubes/2.0.2/30_registry/assets/favicon.png">
+  <style>
+    /* Nubes brand palette — те же цвета что в iot-console.html */
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+      background: #001120; color: #e2ecf6; min-height: 100vh;
+    }
+
+    /* Navbar */
+    .navbar {
+      background: #001C34; border-bottom: 1px solid #0b2d50;
+      padding: 0 28px; height: 58px;
+      display: flex; align-items: center; gap: 14px;
+    }
+    .navbar-logo { display: flex; align-items: center; gap: 10px; text-decoration: none; }
+    .navbar-logo img { height: 18px; filter: brightness(0) invert(1); }
+    .navbar-logo-sep { width: 1px; height: 18px; background: #1a4a73; margin: 0 4px; }
+    .navbar-title { font-size: 15px; font-weight: 600; color: #e2ecf6; }
+    .navbar-badge {
+      background: #2d1a00; border: 1px solid #7a3a00; color: #f0a030;
+      font-size: 10px; font-weight: 700; padding: 2px 7px; border-radius: 4px;
+      letter-spacing: 0.5px; text-transform: uppercase;
+    }
+    .navbar-spacer { flex: 1; }
+    .navbar-refresh {
+      background: #0f3a60; border: 1px solid #1a5a8a; color: #7fc8f8;
+      padding: 6px 14px; border-radius: 6px; font-size: 13px; cursor: pointer;
+      transition: background 0.15s;
+    }
+    .navbar-refresh:hover { background: #1a5080; }
+    .navbar-refresh:disabled { opacity: 0.4; cursor: not-allowed; }
+
+    /* Layout */
+    .container { max-width: 1280px; margin: 0 auto; padding: 28px 24px; }
+
+    /* Auth box */
+    .auth-box {
+      background: #001929; border: 1px solid #0b2d50; border-radius: 12px;
+      padding: 40px; max-width: 480px; margin: 80px auto;
+      display: flex; flex-direction: column; gap: 16px;
+    }
+    .auth-box h2 { font-size: 20px; font-weight: 600; color: #7fc8f8; }
+    .auth-box p { font-size: 13px; color: #6b8eaa; }
+    .auth-input {
+      background: #001120; border: 1px solid #1a4a73; color: #e2ecf6;
+      padding: 10px 14px; border-radius: 8px; font-size: 14px; font-family: monospace;
+      width: 100%; outline: none;
+    }
+    .auth-input:focus { border-color: #1a7fd4; }
+    .auth-btn {
+      background: #1a7fd4; border: none; color: #fff;
+      padding: 10px 20px; border-radius: 8px; font-size: 14px; cursor: pointer;
+      font-weight: 600; transition: background 0.15s;
+    }
+    .auth-btn:hover { background: #1a6ab8; }
+    .auth-error { color: #f87171; font-size: 13px; }
+
+    /* Section header */
+    .section-header {
+      display: flex; align-items: center; gap: 10px;
+      margin-bottom: 16px; padding-bottom: 10px;
+      border-bottom: 1px solid #0b2d50;
+    }
+    .section-icon { width: 20px; height: 20px; opacity: 0.7; }
+    .section-title { font-size: 16px; font-weight: 600; color: #a0c4e8; }
+    .section { margin-bottom: 32px; }
+
+    /* Cards grid */
+    .cards { display: grid; grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); gap: 16px; }
+
+    /* Stat card */
+    .card {
+      background: #001929; border: 1px solid #0b2d50; border-radius: 10px;
+      padding: 20px;
+    }
+    .card-title { font-size: 12px; color: #6b8eaa; text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 8px; }
+    .card-value { font-size: 28px; font-weight: 700; color: #e2ecf6; }
+    .card-sub { font-size: 12px; color: #6b8eaa; margin-top: 4px; }
+    .card-accent { color: #1a7fd4; }
+    .card-warn { color: #f59e0b; }
+    .card-ok { color: #34d399; }
+    .card-err { color: #f87171; }
+
+    /* Pod status card */
+    .pod-card {
+      background: #001929; border: 1px solid #0b2d50; border-radius: 10px;
+      padding: 20px; display: flex; flex-direction: column; gap: 8px;
+    }
+    .pod-name { font-size: 13px; font-weight: 600; color: #7fc8f8; font-family: monospace; }
+    .pod-row { display: flex; justify-content: space-between; font-size: 12px; }
+    .pod-label { color: #6b8eaa; }
+    .pod-val { color: #e2ecf6; }
+    .badge {
+      display: inline-block; padding: 2px 8px; border-radius: 4px;
+      font-size: 11px; font-weight: 700;
+    }
+    .badge-ok { background: #052e16; color: #34d399; border: 1px solid #064e3b; }
+    .badge-warn { background: #2d1c00; color: #f59e0b; border: 1px solid #4d3000; }
+    .badge-err { background: #300; color: #f87171; border: 1px solid #500; }
+
+    /* Tenant table */
+    .tenant-table { width: 100%; border-collapse: collapse; font-size: 13px; }
+    .tenant-table th {
+      text-align: left; padding: 8px 12px; color: #6b8eaa;
+      border-bottom: 1px solid #0b2d50; font-weight: 600; font-size: 11px;
+      text-transform: uppercase; letter-spacing: 0.3px;
+    }
+    .tenant-table td { padding: 10px 12px; border-bottom: 1px solid #071a28; vertical-align: top; }
+    .tenant-table tr:last-child td { border-bottom: none; }
+    .tenant-table tr:hover td { background: rgba(26,127,212,0.05); }
+    .ns-tag {
+      font-family: monospace; font-size: 12px; color: #7fc8f8;
+      background: #0b2d50; padding: 2px 6px; border-radius: 4px;
+    }
+    .num-big { font-size: 16px; font-weight: 600; color: #e2ecf6; }
+    .num-small { font-size: 12px; color: #6b8eaa; }
+
+    /* Latest msgs mini list */
+    .latest-list { display: flex; flex-direction: column; gap: 4px; }
+    .latest-item {
+      background: #001120; border: 1px solid #0b2d50; border-radius: 6px;
+      padding: 6px 10px; font-size: 11px;
+    }
+    .latest-dev { color: #7fc8f8; font-weight: 600; }
+    .latest-ts { color: #6b8eaa; margin-left: 6px; }
+    .latest-payload { color: #a0c4e8; margin-top: 2px; word-break: break-all; font-family: monospace; }
+
+    /* Last updated */
+    .last-updated { font-size: 12px; color: #2d5070; text-align: center; margin-top: 16px; }
+
+    /* Status dot */
+    .dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; margin-right: 6px; }
+    .dot-ok { background: #34d399; }
+    .dot-warn { background: #f59e0b; }
+    .dot-err { background: #f87171; }
+
+    /* Kafka lag bar */
+    .lag-bar-wrap { background: #001120; border-radius: 4px; height: 6px; margin-top: 8px; overflow: hidden; }
+    .lag-bar { height: 100%; border-radius: 4px; transition: width 0.5s; min-width: 2px; }
+    .lag-bar-ok { background: #34d399; }
+    .lag-bar-warn { background: #f59e0b; }
+
+    /* Spinner */
+    .spinner {
+      border: 3px solid #0b2d50; border-top-color: #1a7fd4;
+      border-radius: 50%; width: 32px; height: 32px;
+      animation: spin 0.8s linear infinite;
+      margin: 60px auto;
+    }
+    @keyframes spin { to { transform: rotate(360deg); } }
+
+    /* Error banner */
+    .error-banner {
+      background: #1a0000; border: 1px solid #5a0000; color: #f87171;
+      padding: 12px 16px; border-radius: 8px; font-size: 13px; margin-bottom: 20px;
+    }
+
+    /* Auto-refresh indicator */
+    .refresh-timer {
+      font-size: 11px; color: #2d5070; display: flex; align-items: center; gap: 6px;
+    }
+    .refresh-progress {
+      width: 60px; height: 2px; background: #0b2d50; border-radius: 2px; overflow: hidden;
+    }
+    .refresh-bar {
+      height: 100%; background: #1a7fd4; border-radius: 2px;
+      transition: width 1s linear;
+    }
+  </style>
+</head>
+<body>
+
+<!-- Navbar -->
+<nav class="navbar">
+  <a class="navbar-logo" href="#" aria-label="Nubes">
+    <img src="https://terra.k8c.ru/docs/nubes/nubes/2.0.2/30_registry/assets/logo.svg" alt="Nubes">
+  </a>
+  <div class="navbar-logo-sep"></div>
+  <span class="navbar-title">IoT Admin</span>
+  <span class="navbar-badge">Admin Only</span>
+  <div class="navbar-spacer"></div>
+  <div class="refresh-timer" id="refreshTimer" style="display:none">
+    <span id="refreshCountdown">30</span>s
+    <div class="refresh-progress"><div class="refresh-bar" id="refreshBar" style="width:100%"></div></div>
+  </div>
+  <button class="navbar-refresh" id="btnRefresh" onclick="loadStats()" disabled>Обновить</button>
+</nav>
+
+<!-- Main content -->
+<div class="container">
+  <!-- Auth box (показывается до ввода токена) -->
+  <div class="auth-box" id="authBox">
+    <h2>Доступ для администратора</h2>
+    <p>Введите ADMIN_STATS_TOKEN для просмотра статистики IoT pipeline.</p>
+    <input class="auth-input" id="tokenInput" type="password"
+           placeholder="Bearer token..." autocomplete="off"
+           onkeydown="if(event.key==='Enter') doAuth()">
+    <button class="auth-btn" onclick="doAuth()">Войти</button>
+    <div class="auth-error" id="authError" style="display:none"></div>
+  </div>
+
+  <!-- Контент (показывается после авторизации) -->
+  <div id="mainContent" style="display:none">
+    <div class="error-banner" id="errorBanner" style="display:none"></div>
+
+    <!-- Spinner при загрузке -->
+    <div class="spinner" id="spinner"></div>
+
+    <!-- Данные -->
+    <div id="dataContent" style="display:none">
+
+      <!-- Kafka -->
+      <div class="section">
+        <div class="section-header">
+          <svg class="section-icon" viewBox="0 0 24 24" fill="none" stroke="#7fc8f8" stroke-width="2">
+            <path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>
+          </svg>
+          <span class="section-title">Kafka</span>
+        </div>
+        <div class="cards" id="kafkaCards"></div>
+      </div>
+
+      <!-- K8s Pods -->
+      <div class="section">
+        <div class="section-header">
+          <svg class="section-icon" viewBox="0 0 24 24" fill="none" stroke="#7fc8f8" stroke-width="2">
+            <rect x="2" y="3" width="20" height="14" rx="2"/><path d="M8 21h8M12 17v4"/>
+          </svg>
+          <span class="section-title">Pods</span>
+        </div>
+        <div class="cards" id="podCards"></div>
+      </div>
+
+      <!-- PostgreSQL per tenant -->
+      <div class="section">
+        <div class="section-header">
+          <svg class="section-icon" viewBox="0 0 24 24" fill="none" stroke="#7fc8f8" stroke-width="2">
+            <ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5v14c0 1.66 4.03 3 9 3s9-1.34 9-3V5"/>
+            <path d="M3 12c0 1.66 4.03 3 9 3s9-1.34 9-3"/>
+          </svg>
+          <span class="section-title">PostgreSQL — Telemetry</span>
+        </div>
+        <div class="cards" style="margin-bottom:16px" id="pgSummaryCards"></div>
+        <div style="background:#001929;border:1px solid #0b2d50;border-radius:10px;overflow:auto">
+          <table class="tenant-table" id="tenantTable">
+            <thead>
+              <tr>
+                <th>Namespace</th>
+                <th>Total</th>
+                <th>Last 1h</th>
+                <th>Last 24h</th>
+                <th>Последние сообщения</th>
+              </tr>
+            </thead>
+            <tbody id="tenantTableBody"></tbody>
+          </table>
+        </div>
+      </div>
+
+      <div class="last-updated" id="lastUpdated"></div>
+    </div>
+  </div>
+</div>
+
+<script>
+// ── State ──────────────────────────────────────────────────────────────────
+const API_BASE = window.location.origin;
+let adminToken = sessionStorage.getItem('iot_admin_token') || '';
+let refreshInterval = null;
+let refreshCountdown = 30;
+
+// ── Auth ───────────────────────────────────────────────────────────────────
+function doAuth() {
+  const input = document.getElementById('tokenInput').value.trim();
+  if (!input) return;
+  adminToken = input;
+  sessionStorage.setItem('iot_admin_token', adminToken);
+  document.getElementById('authBox').style.display = 'none';
+  document.getElementById('mainContent').style.display = 'block';
+  loadStats();
+}
+
+function showAuthError(msg) {
+  const el = document.getElementById('authError');
+  el.textContent = msg;
+  el.style.display = 'block';
+  // Сбрасываем токен — он не подошёл
+  adminToken = '';
+  sessionStorage.removeItem('iot_admin_token');
+  document.getElementById('authBox').style.display = 'block';
+  document.getElementById('mainContent').style.display = 'none';
+  if (refreshInterval) { clearInterval(refreshInterval); refreshInterval = null; }
+  document.getElementById('refreshTimer').style.display = 'none';
+}
+
+// Если токен уже в sessionStorage — пропускаем auth box
+if (adminToken) {
+  document.getElementById('authBox').style.display = 'none';
+  document.getElementById('mainContent').style.display = 'block';
+  document.getElementById('spinner').style.display = 'block';
+}
+
+// ── Load stats ─────────────────────────────────────────────────────────────
+async function loadStats() {
+  if (!adminToken) return;
+  document.getElementById('btnRefresh').disabled = true;
+  document.getElementById('spinner').style.display = 'block';
+  document.getElementById('dataContent').style.display = 'none';
+  document.getElementById('errorBanner').style.display = 'none';
+
+  resetRefreshTimer();
+
+  try {
+    const resp = await fetch(`${API_BASE}/iot-admin/stats`, {
+      headers: { 'Authorization': `Bearer ${adminToken}` }
+    });
+
+    if (resp.status === 401 || resp.status === 503) {
+      const body = await resp.json().catch(() => ({}));
+      showAuthError(body.error || 'Ошибка авторизации');
+      document.getElementById('spinner').style.display = 'none';
+      return;
+    }
+
+    if (!resp.ok) {
+      throw new Error(`HTTP ${resp.status}`);
+    }
+
+    const data = await resp.json();
+    renderAll(data);
+    document.getElementById('spinner').style.display = 'none';
+    document.getElementById('dataContent').style.display = 'block';
+    document.getElementById('refreshTimer').style.display = 'flex';
+    document.getElementById('lastUpdated').textContent =
+      'Обновлено: ' + new Date(data.collected_at).toLocaleTimeString('ru-RU');
+    setupAutoRefresh();
+  } catch (e) {
+    document.getElementById('spinner').style.display = 'none';
+    showBanner('Ошибка загрузки данных: ' + e.message);
+    document.getElementById('dataContent').style.display = 'block';
+  } finally {
+    document.getElementById('btnRefresh').disabled = false;
+  }
+}
+
+function showBanner(msg) {
+  const el = document.getElementById('errorBanner');
+  el.textContent = msg;
+  el.style.display = 'block';
+}
+
+// ── Auto-refresh ───────────────────────────────────────────────────────────
+function setupAutoRefresh() {
+  if (refreshInterval) return; // уже запущен
+  refreshInterval = setInterval(() => {
+    refreshCountdown--;
+    document.getElementById('refreshCountdown').textContent = refreshCountdown;
+    const pct = (refreshCountdown / 30) * 100;
+    document.getElementById('refreshBar').style.width = pct + '%';
+    if (refreshCountdown <= 0) {
+      clearInterval(refreshInterval);
+      refreshInterval = null;
+      loadStats();
+    }
+  }, 1000);
+}
+
+function resetRefreshTimer() {
+  if (refreshInterval) { clearInterval(refreshInterval); refreshInterval = null; }
+  refreshCountdown = 30;
+  document.getElementById('refreshCountdown').textContent = '30';
+  document.getElementById('refreshBar').style.width = '100%';
+}
+
+// ── Render ─────────────────────────────────────────────────────────────────
+function renderAll(data) {
+  renderKafka(data.kafka || {});
+  renderPods(data.pods || {});
+  renderPostgres(data.postgres || {});
+}
+
+// Kafka section
+function renderKafka(kafka) {
+  const el = document.getElementById('kafkaCards');
+  if (kafka.error) {
+    el.innerHTML = `<div class="card"><div class="card-title">Ошибка</div>
+      <div class="card-value card-err" style="font-size:14px">${esc(kafka.error)}</div></div>`;
+    return;
+  }
+
+  const lag = kafka.consumer_lag || 0;
+  const latest = kafka.latest_offset || 0;
+  const committed = kafka.committed_offset || 0;
+  const lagClass = lag === 0 ? 'card-ok' : lag < 100 ? 'card-warn' : 'card-err';
+  const barClass = lag === 0 ? 'lag-bar-ok' : 'lag-bar-warn';
+  const barWidth = latest > 0 ? Math.max(2, Math.round((committed / latest) * 100)) : 100;
+
+  el.innerHTML = `
+    <div class="card">
+      <div class="card-title">Consumer Lag</div>
+      <div class="card-value ${lagClass}">${lag}</div>
+      <div class="card-sub">iot-pg-consumer / iot.telemetry</div>
+      <div class="lag-bar-wrap"><div class="lag-bar ${barClass}" style="width:${barWidth}%"></div></div>
+    </div>
+    <div class="card">
+      <div class="card-title">Latest Offset (всего прошло)</div>
+      <div class="card-value card-accent">${latest.toLocaleString()}</div>
+      <div class="card-sub">Kafka log end offset</div>
+    </div>
+    <div class="card">
+      <div class="card-title">Committed Offset</div>
+      <div class="card-value">${committed.toLocaleString()}</div>
+      <div class="card-sub">Consumer обработал</div>
+    </div>`;
+}
+
+// Pods section
+function renderPods(pods) {
+  const el = document.getElementById('podCards');
+  el.innerHTML = '';
+
+  const labels = {
+    'iot-mqtt-bridge': 'MQTT Bridge',
+    'iot-kafka-consumer': 'Kafka Consumer'
+  };
+
+  for (const [key, pod] of Object.entries(pods)) {
+    const title = labels[key] || key;
+    if (pod.error || pod.status === 'not found') {
+      el.innerHTML += `
+        <div class="pod-card">
+          <div class="pod-name">${esc(title)}</div>
+          <div style="color:#f87171;font-size:12px">${esc(pod.error || 'Pod not found')}</div>
+        </div>`;
+      continue;
+    }
+
+    const readyBadge = pod.ready
+      ? '<span class="badge badge-ok">Ready</span>'
+      : '<span class="badge badge-warn">Not Ready</span>';
+    const restartColor = pod.restarts > 5 ? 'card-err' : pod.restarts > 0 ? 'card-warn' : 'card-ok';
+
+    el.innerHTML += `
+      <div class="pod-card">
+        <div class="pod-name">
+          <span class="dot dot-${pod.ready ? 'ok' : 'warn'}"></span>${esc(title)}
+        </div>
+        <div class="pod-row"><span class="pod-label">Pod</span><span class="pod-val" style="font-family:monospace;font-size:11px">${esc(pod.name)}</span></div>
+        <div class="pod-row"><span class="pod-label">Phase</span><span class="pod-val">${esc(pod.phase)} ${readyBadge}</span></div>
+        <div class="pod-row"><span class="pod-label">Restarts</span><span class="pod-val ${restartColor}">${pod.restarts}</span></div>
+        <div class="pod-row"><span class="pod-label">Age</span><span class="pod-val">${esc(pod.age)}</span></div>
+      </div>`;
+  }
+}
+
+// Postgres section
+function renderPostgres(pg) {
+  const summaryEl = document.getElementById('pgSummaryCards');
+  const tbodyEl = document.getElementById('tenantTableBody');
+
+  if (!pg.reachable) {
+    summaryEl.innerHTML = `<div class="card"><div class="card-title">Ошибка</div>
+      <div class="card-value card-err" style="font-size:14px">${esc(pg.error || 'Unreachable')}</div></div>`;
+    tbodyEl.innerHTML = '';
+    return;
+  }
+
+  const tenants = pg.tenants || [];
+  const totalAll = pg.total_all || 0;
+
+  summaryEl.innerHTML = `
+    <div class="card">
+      <div class="card-title">Всего записей</div>
+      <div class="card-value card-accent">${totalAll.toLocaleString()}</div>
+      <div class="card-sub">Все tenant, iot_telemetry</div>
+    </div>
+    <div class="card">
+      <div class="card-title">Tenant-ов</div>
+      <div class="card-value">${tenants.length}</div>
+      <div class="card-sub">Активных namespace</div>
+    </div>`;
+
+  tbodyEl.innerHTML = tenants.map(t => {
+    if (t.error) {
+      return `<tr><td><span class="ns-tag">${esc(t.namespace)}</span></td>
+        <td colspan="4" style="color:#f87171">${esc(t.error)}</td></tr>`;
+    }
+    const latest = (t.latest || []).slice(0, 3);
+    const latestHtml = latest.length === 0
+      ? '<span style="color:#2d5070">нет данных</span>'
+      : `<div class="latest-list">${latest.map(row => `
+          <div class="latest-item">
+            <span class="latest-dev">${esc(row.device_id)}</span>
+            <span class="latest-ts">${formatTs(row.ts)}</span>
+            <div class="latest-payload">${esc(truncate(JSON.stringify(row.payload), 80))}</div>
+          </div>`).join('')}</div>`;
+
+    return `<tr>
+      <td><span class="ns-tag">${esc(t.namespace)}</span><br>
+          <span style="font-size:11px;color:#2d5070">${esc(t.db_name)}</span></td>
+      <td><span class="num-big">${(t.total||0).toLocaleString()}</span></td>
+      <td><span class="num-small">${(t.last_1h||0).toLocaleString()}</span></td>
+      <td><span class="num-small">${(t.last_24h||0).toLocaleString()}</span></td>
+      <td>${latestHtml}</td>
+    </tr>`;
+  }).join('');
+}
+
+// ── Utils ──────────────────────────────────────────────────────────────────
+function esc(str) {
+  if (str == null) return '';
+  return String(str).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+}
+
+function truncate(str, len) {
+  if (!str) return '';
+  return str.length > len ? str.slice(0, len) + '…' : str;
+}
+
+function formatTs(ts) {
+  if (!ts) return '';
+  try {
+    const d = new Date(ts);
+    return d.toLocaleTimeString('ru-RU', {hour:'2-digit', minute:'2-digit', second:'2-digit'});
+  } catch { return ts; }
+}
+
+// ── Init ───────────────────────────────────────────────────────────────────
+if (adminToken) {
+  loadStats();
+}
+</script>
+</body>
+</html>

internal/service/api/ui/landing.html

@@ -0,0 +1,362 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>IoT — приём телеметрии устройств (Nubes)</title>
+<link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+<style>
+:root {
+  --brand-primary: #2563eb;
+  --brand-primary-dark: #1d4ed8;
+  --brand-gray: #d1d5db;
+  --brand-grey-light: #f3f4f6;
+  --text-primary: #1a1a1a;
+  --text-muted: #6b7280;
+  --success: #16a34a;
+  --warning: #d97706;
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  font-family: system-ui, "Segoe UI", Roboto, sans-serif;
+  font-size: 14px;
+  color: var(--text-primary);
+  background: #fafafa;
+  line-height: 1.5;
+}
+.topbar {
+  height: 56px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 0 16px;
+  background: #fff;
+  border-bottom: 1px solid var(--brand-gray);
+  position: sticky;
+  top: 0;
+}
+.topbar .brand { font-weight: 600; color: var(--text-primary); }
+.topbar .muted { color: var(--text-muted); }
+.topbar .spacer { flex: 1; }
+.chip {
+  font-family: ui-monospace, monospace;
+  font-size: 12px;
+  color: var(--brand-primary);
+  background: #eff6ff;
+  border: 1px solid #bfdbfe;
+  border-radius: 999px;
+  padding: 2px 10px;
+}
+.container { max-width: 880px; margin: 0 auto; padding: 24px 16px 48px; }
+.hero { display: flex; align-items: center; gap: 16px; margin-bottom: 24px; }
+.hero h1 { font-size: 24px; margin: 0; letter-spacing: -0.3px; }
+.hero .sub { color: var(--text-muted); margin: 4px 0 0; }
+.badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--warning);
+  background: #fffbeb;
+  border: 1px solid #fde68a;
+  border-radius: 999px;
+  padding: 2px 10px;
+  margin-left: 8px;
+}
+.card {
+  background: #fff;
+  border: 1px solid var(--brand-gray);
+  border-radius: 12px;
+  box-shadow: 0 1px 2px rgba(0,0,0,0.05);
+  margin-bottom: 20px;
+  overflow: hidden;
+}
+.card-header {
+  background: var(--brand-grey-light);
+  padding: 12px;
+  font-weight: 600;
+  font-size: 14px;
+}
+.card-body { padding: 12px; }
+.card-body > p:first-child { margin-top: 0; }
+.card-body > p:last-child { margin-bottom: 0; }
+.kv { display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }
+.kv .k { color: var(--text-muted); }
+.kv .v { font-family: ui-monospace, Menlo, Consolas, monospace; font-size: 13px; word-break: break-all; }
+a { color: var(--brand-primary); text-decoration: none; }
+a:hover { color: var(--brand-primary-dark); text-decoration: underline; }
+pre {
+  background: var(--brand-grey-light);
+  border: 1px solid var(--brand-gray);
+  border-radius: 8px;
+  padding: 12px;
+  overflow-x: auto;
+  font-family: ui-monospace, Menlo, Consolas, monospace;
+  font-size: 12.5px;
+  line-height: 1.6;
+  margin: 8px 0 0;
+}
+pre code { background: none; border: none; padding: 0; }
+.status-ok { color: var(--success); font-weight: 600; }
+.footer { color: var(--text-muted); font-size: 12px; text-align: center; margin-top: 32px; }
+.step { display: flex; gap: 14px; margin-bottom: 18px; }
+.step:last-child { margin-bottom: 0; }
+.step-num {
+  flex: 0 0 30px;
+  height: 30px;
+  border-radius: 999px;
+  background: var(--brand-primary);
+  color: #fff;
+  font-weight: 700;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 15px;
+}
+.step-body { flex: 1; }
+.step-title { font-weight: 600; font-size: 15px; margin-bottom: 2px; }
+.step-body p { color: #374151; margin: 4px 0; }
+.btn-hero {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  background: var(--brand-primary);
+  color: #fff !important;
+  text-decoration: none !important;
+  font-size: 15px;
+  font-weight: 600;
+  padding: 10px 20px;
+  border-radius: 8px;
+  margin-top: 8px;
+}
+.btn-hero:hover { background: var(--brand-primary-dark); }
+.hint-box {
+  font-size: 14px;
+  color: #374151;
+  background: var(--brand-grey-light);
+  border: 1px solid var(--brand-gray);
+  border-radius: 8px;
+  padding: 10px 14px;
+  margin-top: 10px;
+  line-height: 1.7;
+}
+.hint-box code { font-family: ui-monospace, Menlo, Consolas, monospace; font-size: 13px; }
+/* Схема пайплайна */
+.flow {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  align-items: stretch;
+  margin: 10px 0 4px;
+}
+.flow-node {
+  border: 1px solid var(--brand-gray);
+  border-radius: 10px;
+  background: #fff;
+  padding: 10px 12px;
+  min-width: 110px;
+  text-align: center;
+  box-shadow: 0 1px 2px rgba(0,0,0,0.04);
+}
+.flow-node .fn-title { font-weight: 600; font-size: 13.5px; }
+.flow-node .fn-sub {
+  font-family: ui-monospace, Menlo, Consolas, monospace;
+  font-size: 11.5px;
+  color: var(--text-muted);
+  margin-top: 3px;
+  word-break: break-all;
+}
+.flow-node.acc { border-color: #bfdbfe; background: #eff6ff; }
+.flow-node.acc .fn-title { color: var(--brand-primary); }
+.flow-arrow {
+  align-self: center;
+  color: var(--text-muted);
+  font-size: 16px;
+  padding: 0 2px;
+}
+.flow-caption { color: var(--text-muted); font-size: 12px; margin-top: 6px; }
+.pipeline { width: 100%; max-width: 640px; display: block; margin: 12px auto 4px; }
+</style>
+</head>
+<body>
+
+<div class="topbar">
+  <img src="/static/logo.svg" height="18" alt="nubes">
+  <span class="brand">Nubes</span>
+  <span class="muted">· IoT</span>
+  <span class="spacer"></span>
+  <span class="chip">{{VERSION}}</span>
+</div>
+
+<div class="container">
+
+  <div class="hero">
+    <img src="/static/logo.svg" height="28" alt="nubes">
+    <div>
+      <h1>IoT <span class="badge">тестирование</span></h1>
+      <p class="sub">Это база телеметрии. Устройства шлют сюда показания по MQTT —
+      показания сохраняются и доступны через API и консоль. Ниже — как отправить
+      первое показание за 2 минуты.</p>
+    </div>
+  </div>
+
+  <div class="card">
+    <div class="card-header">Как это работает</div>
+    <div class="card-body">
+      <p>Устройство (датчик, бойлер, счётчик) отправляет показания по протоколу
+      MQTT. Дальше показания проходят по цепочке и попадают в базу данных:</p>
+      <img class="pipeline" src="/static/pipeline.svg" alt="Схема пайплайна IoT">
+      <div class="flow-caption">
+        Между брокером и базой работают бридж и потребитель (части iot-service):
+        бридж кладёт показания в очередь, потребитель пишет их в базу.
+      </div>
+      <p style="color:#374151">
+        Очередь <code>iot-telemetry</code> — внутренний буфер сервиса: она
+        защищает показания от потерь при всплесках и сбоях базы. Пользователю
+        креды очереди НЕ нужны — сервис ходит в неё сам. Если требуется
+        посмотреть сообщения вручную — консоль очереди:
+        <a href="https://sqs.containerk8s.dev.nubes.ru/ui">sqs.containerk8s.dev.nubes.ru/ui</a>
+        (вход по API-токену Nubes; описание — на
+        <a href="https://sqs.containerk8s.dev.nubes.ru/">sqs.containerk8s.dev.nubes.ru</a>).
+      </p>
+      <p style="color:#374151">
+        У каждого устройства — свои логин и пароль, поэтому чужое устройство не
+        сможет писать в ваш топик. Данные разных проектов (namespace) лежат в
+        разных базах и не смешиваются.
+      </p>
+      <p><b>Три понятия:</b></p>
+      <p style="color:#374151">
+        <b>namespace</b> — имя вашего проекта/группы устройств (например
+        <code>myhome</code>);<br>
+        <b>device_id</b> — идентификатор конкретного устройства (например
+        <code>boiler-1</code>);<br>
+        <b>топик</b> — адрес, в который устройство отправляет показания:
+        <code>namespace/telemetry/device_id</code>.
+      </p>
+    </div>
+  </div>
+
+  <div class="card">
+    <div class="card-header">Быстрый старт — 4 шага</div>
+    <div class="card-body">
+
+      <div class="step">
+        <div class="step-num">1</div>
+        <div class="step-body">
+          <div class="step-title">Получить токен доступа к API</div>
+          <p>Все команды API требуют заголовок <code>Authorization: Bearer
+          &lt;токен&gt;</code>. Для тестов подойдёт самодельный токен: сервис
+          проверяет только два поля (кто и до какого времени), подпись не
+          проверяется. Одна команда — токен готов:</p>
+          <div class="hint-box">
+            <code>TOKEN=$(python3 -c "import base64,json,time;h=base64.urlsafe_b64encode(b'{\"alg\":\"none\",\"typ\":\"JWT\"}').rstrip(b'=').decode();p=base64.urlsafe_b64encode(json.dumps({'sub':'admin','exp':int(time.time())+86400}).encode()).rstrip(b'=').decode();print(h+'.'+p+'.sig')")</code>
+          </div>
+        </div>
+      </div>
+
+      <div class="step">
+        <div class="step-num">2</div>
+        <div class="step-body">
+          <div class="step-title">Зарегистрировать устройство</div>
+          <p>Одна команда — и устройство <code>boiler-1</code> появляется в
+          проекте <code>myhome</code>. В ответе будет логин для MQTT
+          (<code>myhome_boiler-1</code>). Пароль в ответе НЕ показывается —
+          его отдаёт второй запрос.</p>
+          <div class="hint-box">
+            <code>curl -X POST -H "Authorization: Bearer $TOKEN" \<br>
+  -H "Content-Type: application/json" \<br>
+  -d '{"name":"boiler","device_id":"boiler-1"}' \<br>
+  https://iot.containerk8s.dev.nubes.ru/v1/namespaces/myhome/iot/devices</code><br>
+            <br><code># пароль — во втором запросе (поле mqtt_password):</code><br>
+            <code>curl -H "Authorization: Bearer $TOKEN" \<br>
+  https://iot.containerk8s.dev.nubes.ru/v1/namespaces/myhome/iot/devices/boiler</code>
+          </div>
+        </div>
+      </div>
+
+      <div class="step">
+        <div class="step-num">3</div>
+        <div class="step-body">
+          <div class="step-title">Отправить показание</div>
+          <p>Подключение к MQTT — по адресу
+          <code>wss://exqx.containerk8s.dev.nubes.ru/mqtt</code>. Логин —
+          <code>myhome_boiler-1</code>, пароль — из шага 2. Показание
+          отправляется в топик <code>myhome/telemetry/boiler-1</code>.</p>
+          <div class="hint-box">
+            <code>import paho.mqtt.client as mqtt, json</code><br>
+            <code>c = mqtt.Client(transport="websockets")</code><br>
+            <code>c.ws_set_options(path="/mqtt")</code><br>
+            <code>c.username_pw_set("myhome_boiler-1", "&lt;пароль из шага 2&gt;")</code><br>
+            <code>c.connect("exqx.containerk8s.dev.nubes.ru", 443)</code><br>
+            <code>c.publish("myhome/telemetry/boiler-1", json.dumps({"temp": 58.3}))</code>
+          </div>
+        </div>
+      </div>
+
+      <div class="step">
+        <div class="step-num">4</div>
+        <div class="step-body">
+          <div class="step-title">Увидеть результат</div>
+          <p>Показание доходит в базу за ~1 секунду. Посмотреть — запросом или
+          в консоли:</p>
+          <div class="hint-box">
+            <code>curl -H "Authorization: Bearer $TOKEN" \<br>
+  "https://iot.containerk8s.dev.nubes.ru/v1/namespaces/myhome/iot/telemetry?limit=50"</code>
+          </div>
+          <a class="btn-hero" href="/console">Открыть консоль →</a>
+        </div>
+      </div>
+
+    </div>
+  </div>
+
+  <div class="card">
+    <div class="card-header">Подключение</div>
+    <div class="card-body kv">
+      <div class="k">MQTT endpoint</div>
+      <div class="v">wss://exqx.containerk8s.dev.nubes.ru/mqtt</div>
+      <div class="k">Протокол</div>
+      <div class="v">MQTT 3.1.1 / 5.0 over WebSocket (subprotocol <code>mqtt</code>), TLS</div>
+      <div class="k">REST API</div>
+      <div class="v">https://iot.containerk8s.dev.nubes.ru</div>
+      <div class="k">Аутентификация MQTT</div>
+      <div class="v">username <code>{namespace}_{device_id}</code> + пароль из API</div>
+      <div class="k">Аутентификация REST</div>
+      <div class="v">Bearer JWT (<code>sub</code>, <code>exp</code>)</div>
+      <div class="k">Топик устройства</div>
+      <div class="v">{namespace}/telemetry/{device_id}</div>
+      <div class="k">Консоль</div>
+      <div class="v"><a href="/console">/console</a> — устройства, эмулятор, телеметрия</div>
+      <div class="k">Админ-статистика</div>
+      <div class="v"><a href="/iot-admin">/iot-admin</a> (токен ADMIN_STATS_TOKEN)</div>
+      <div class="k">Health</div>
+      <div class="v"><a href="/health">GET /health</a> <span class="status-ok">● ok</span></div>
+    </div>
+  </div>
+
+  <div class="card">
+    <div class="card-header">MQTT endpoint (exqx)</div>
+    <div class="card-body">
+      <p style="color:#374151">
+        <code>exqx.containerk8s.dev.nubes.ru</code> — это MQTT-брокер, а не
+        веб-страница. Точка подключения — только <code>/mqtt</code> через
+        WebSocket. Если открыть этот адрес в браузере, вернётся
+        <code>400</code> — так и должно быть: браузер не использует
+        WebSocket-подпротокол <code>mqtt</code>. Подключаться нужно MQTT-
+        клиентом (paho-mqtt, mqtt.js и т.п.), как в шаге 3.
+      </p>
+      <p style="color:#374151">
+        Ограничения: сообщение — до ~250 КБ; платформа может разрывать
+        внешние WebSocket-соединения примерно раз в 150 секунд — клиент
+        должен уметь переподключаться (в paho это делается автоматически).
+      </p>
+    </div>
+  </div>
+
+  <div class="footer">iot-service · realm iot-naeel · версия {{VERSION}} · <a href="/console">консоль</a> · <a href="/iot-admin">админ</a> · <a href="/health">health</a></div>
+
+</div>
+</body>
+</html>

internal/service/api/ui/static/favicon.svg

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="57"
+   height="57"
+   xml:space="preserve"
+   overflow="hidden"
+   version="1.1"
+   id="svg8"
+   sodipodi:docname="U_v3.svg"
+   inkscape:version="1.3.2 (091e20e, 2023-11-25, custom)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg"><sodipodi:namedview
+     id="namedview8"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="16.226667"
+     inkscape:cx="27.146672"
+     inkscape:cy="28.317584"
+     inkscape:window-width="2560"
+     inkscape:window-height="1494"
+     inkscape:window-x="-11"
+     inkscape:window-y="-11"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg8" /><defs
+     id="defs2"><clipPath
+       id="clip0"><rect
+         x="652"
+         y="420"
+         width="64"
+         height="75"
+         id="rect1" /></clipPath><clipPath
+       id="clip1"><rect
+         x="652"
+         y="420"
+         width="64"
+         height="70"
+         id="rect2" /></clipPath></defs><g
+     clip-path="url(#clip0)"
+     transform="matrix(1.0135748,0,0,1.0135748,-664.97034,-440.30567)"
+     id="g8"><g
+       clip-path="url(#clip1)"
+       id="g7"><g
+         id="g6"><path
+           d="m 114.028,43.1492 v 7.6592 c 0,3.7843 -3.08,6.8632 -6.866,6.8632 L 85.3367,57.5419 c -3.7853,0 -6.8655,-3.0805 -6.8655,-6.8643 v -2.5279 l 0.0555,0.009 V 15.8148 l -10.3823,2.0127 0.0045,3.8772 -0.0045,0.0015 v 28.971 c 0,9.481 7.7132,17.1923 17.1867,17.1923 l 21.8359,0.1313 c 9.474,0 17.187,-7.7117 17.187,-17.1928 v -2.6541 l 0.027,0.0045 V 15.8145 l -10.382,2.0126 0.028,25.3214 z"
+           fill="#001c34"
+           fill-rule="evenodd"
+           transform="matrix(1,0,0,1.01337,587.92,420.059)"
+           id="path6" /></g></g></g></svg>

internal/service/api/ui/static/logo.svg

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Creator: CorelDRAW -->
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" width="82.3711mm" height="18.2443mm" version="1.1" style="shape-rendering:geometricPrecision; text-rendering:geometricPrecision; image-rendering:optimizeQuality; fill-rule:evenodd; clip-rule:evenodd"
+viewBox="0 0 8221.93 1821.07"
+ xmlns:xlink="http://www.w3.org/1999/xlink"
+ xmlns:xodm="http://www.corel.com/coreldraw/odm/2003">
+ <defs>
+  <style type="text/css">
+   <![CDATA[
+    .fil0 {fill:#001C34}
+   ]]>
+  </style>
+ </defs>
+ <g id="Слой_x0020_1">
+  <metadata id="CorelCorpID_0Corel-Layer"/>
+  <g id="_2283355517888">
+   <path class="fil0" d="M477.49 479.69l-413.51 0 -63.98 276.48 178.44 0 1.17 1028.71 0 26.75 0.03 0 276.39 0 0 -871.72c0,-101.28 82.43,-183.69 183.75,-183.69l589.25 3.44c101.34,0 183.76,82.46 183.76,183.74l0 871.72 276.44 0 0 -871.72c0,-253.77 -206.46,-460.15 -460.05,-460.15l-589.52 -3.53 -162.17 0.45 0 -0.48z"/>
+   <path class="fil0" d="M6664.65 1813.37l1181.04 0c212.14,0 376.24,-175.01 376.24,-387.08 0,-212.13 -172.55,-384.68 -384.69,-384.68l-653.66 0c-60.22,0 -109.16,-48.94 -109.16,-109.18l0 -66.18c0,-60.19 48.94,-109.14 109.16,-109.14l695.76 0 63.74 -275.49 -759.5 0c-212.13,0 -384.66,172.53 -384.66,384.63l0 66.18c0,212.13 172.53,384.67 384.66,384.67l653.66 0c60.2,0 109.2,49 109.2,109.19 0,60.13 -49,116.1 -109.2,116.1l-1118.9 0 -53.68 270.98z"/>
+   <path class="fil0" d="M6200.79 483.5l-723.21 0c-215.88,0 -391.47,175.6 -391.47,391.51l0 485.5c0,248.38 202.05,450.4 450.4,450.4l989.38 0 62.13 -268.51 -1051.51 0c-96.41,0 -174.95,-85.37 -174.95,-181.88l-1.5 -39.46 923.62 0 308.51 -1.84 0 -237.95 0 -206.26c0,-215.91 -175.59,-391.51 -391.41,-391.51zm115.96 560.28l-955.19 0 0 -168.77c0,-63.96 52.07,-116.05 116.02,-116.05l723.21 0c63.91,0 115.96,52.08 115.96,116.05l0 168.77z"/>
+   <path class="fil0" d="M4683.49 1194.24l0 168.28c0,100.92 -81.7,178.37 -182.67,178.37l-589.87 1.23c-93.18,0 -170.28,-69.96 -181.63,-160.09l0 -458.13c11.36,-90.1 88.46,-160.07 181.63,-160.07l589.44 3.5c100.97,0 183.1,82.18 183.1,183.1l0 30.42 0 213.4zm-1230.2 -345.53l-0.89 -795.03 276.91 -53.68 0 526.07c55.74,-24.16 117.03,-37.74 181.5,-37.74l589.71 3.5c252.69,0 458.42,205.72 458.42,458.59l0 30.42 0 213.4 0 168.28c0,252.86 -205.73,458.54 -458.42,458.54l-589.71 -3.5c-252.7,0 -458.41,-205.67 -458.41,-458.56l0 -171.61 0 -240.48 0.89 -98.2z"/>
+   <path class="fil0" d="M3041.25 1150.84l0 204.28c0,100.93 -82.15,183.05 -183.11,183.05l-582.11 -3.46c-100.96,0 -183.11,-82.16 -183.11,-183.08l0 -67.42 1.48 0.24 0 -862.65 -276.91 53.68 0.12 103.41 -0.12 0.04 0 772.69c0,252.87 205.72,458.54 458.39,458.54l582.4 3.5c252.67,0 458.4,-205.68 458.4,-458.55l0 -70.79 0.71 0.12 0 -862.65 -276.91 53.68 0.76 675.35z"/>
+  </g>
+ </g>
+</svg>

internal/service/api/ui/static/pipeline.svg

@@ -0,0 +1,69 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 1060" width="100%" role="img" aria-label="Схема пайплайна IoT">
+  <defs>
+    <style>
+      text { font-family: system-ui, "Segoe UI", Roboto, sans-serif; }
+      .mono { font-family: ui-monospace, Menlo, Consolas, monospace; }
+    </style>
+    <marker id="arr" markerWidth="10" markerHeight="10" refX="8" refY="3" orient="auto">
+      <path d="M0,0 L8,3 L0,6 Z" fill="#6b7280"/>
+    </marker>
+  </defs>
+
+  <!-- Подложка «ПЛАТФОРМА» -->
+  <text x="104" y="222" font-size="12" fill="#6b7280">ПЛАТФОРМА</text>
+  <rect x="100" y="232" width="440" height="568" rx="16" fill="none"
+        stroke="#bfdbfe" stroke-width="1.5" stroke-dasharray="6 4"/>
+
+  <!-- Переход 1: Устройство → EMQX -->
+  <line x1="320" y1="158" x2="320" y2="242" stroke="#6b7280" stroke-width="2" marker-end="url(#arr)"/>
+  <rect x="175" y="187" width="130" height="26" rx="8" fill="#ffffff" stroke="#d1d5db"/>
+  <text x="240" y="205" font-size="14" fill="#1a1a1a" text-anchor="middle">MQTT over wss</text>
+  <text x="345" y="196" font-size="13" class="mono" fill="#6b7280">{namespace}/</text>
+  <text x="345" y="216" font-size="13" class="mono" fill="#6b7280">telemetry/{device_id}</text>
+
+  <!-- Переход 2: EMQX → Очередь -->
+  <line x1="320" y1="368" x2="320" y2="452" stroke="#6b7280" stroke-width="2" marker-end="url(#arr)"/>
+  <rect x="200" y="397" width="80" height="26" rx="8" fill="#ffffff" stroke="#d1d5db"/>
+  <text x="240" y="415" font-size="14" fill="#1a1a1a" text-anchor="middle">бридж</text>
+  <text x="345" y="416" font-size="13" fill="#6b7280">кладёт показания</text>
+
+  <!-- Переход 3: Очередь → PostgreSQL -->
+  <line x1="320" y1="578" x2="320" y2="662" stroke="#6b7280" stroke-width="2" marker-end="url(#arr)"/>
+  <rect x="175" y="607" width="130" height="26" rx="8" fill="#ffffff" stroke="#d1d5db"/>
+  <text x="240" y="625" font-size="14" fill="#1a1a1a" text-anchor="middle">потребитель</text>
+  <text x="345" y="626" font-size="13" fill="#6b7280">пишет в базу</text>
+
+  <!-- Переход 4: PostgreSQL → API / Консоль -->
+  <line x1="320" y1="788" x2="320" y2="872" stroke="#6b7280" stroke-width="2" marker-end="url(#arr)"/>
+  <rect x="205" y="817" width="70" height="26" rx="8" fill="#ffffff" stroke="#d1d5db"/>
+  <text x="240" y="835" font-size="14" fill="#1a1a1a" text-anchor="middle">REST</text>
+  <text x="345" y="836" font-size="13" fill="#6b7280">чтение истории</text>
+
+  <!-- Блок 1: Устройство -->
+  <rect x="110" y="40" width="420" height="110" rx="12" fill="#ffffff" stroke="#d1d5db"/>
+  <text x="320" y="102" font-size="20" font-weight="600" fill="#1a1a1a" text-anchor="middle">Устройство</text>
+  <text x="320" y="128" font-size="14" class="mono" fill="#6b7280" text-anchor="middle">датчик · MQTT-клиент</text>
+
+  <!-- Блок 2: EMQX -->
+  <rect x="110" y="250" width="420" height="110" rx="12" fill="#eff6ff" stroke="#bfdbfe"/>
+  <text x="320" y="312" font-size="20" font-weight="600" fill="#2563eb" text-anchor="middle">EMQX</text>
+  <text x="320" y="338" font-size="14" class="mono" fill="#6b7280" text-anchor="middle">брокер · wss /mqtt</text>
+
+  <!-- Блок 3: Очередь -->
+  <rect x="110" y="460" width="420" height="110" rx="12" fill="#eff6ff" stroke="#bfdbfe"/>
+  <text x="320" y="522" font-size="20" font-weight="600" fill="#2563eb" text-anchor="middle">Очередь</text>
+  <text x="320" y="548" font-size="14" class="mono" fill="#6b7280" text-anchor="middle">iot-telemetry</text>
+
+  <!-- Блок 4: PostgreSQL -->
+  <rect x="110" y="670" width="420" height="110" rx="12" fill="#eff6ff" stroke="#bfdbfe"/>
+  <text x="320" y="732" font-size="20" font-weight="600" fill="#2563eb" text-anchor="middle">PostgreSQL</text>
+  <text x="320" y="758" font-size="14" class="mono" fill="#6b7280" text-anchor="middle">база на namespace</text>
+
+  <!-- Блок 5: API / Консоль -->
+  <rect x="110" y="880" width="420" height="110" rx="12" fill="#ffffff" stroke="#d1d5db"/>
+  <text x="320" y="942" font-size="20" font-weight="600" fill="#1a1a1a" text-anchor="middle">API / Консоль</text>
+  <text x="320" y="968" font-size="14" class="mono" fill="#6b7280" text-anchor="middle">чтение истории</text>
+
+  <!-- Подвал -->
+  <text x="320" y="1038" font-size="13" fill="#6b7280" text-anchor="middle">бридж и потребитель — части сервиса iot-service</text>
+</svg>

internal/service/bridge/bridge.go

@@ -0,0 +1,116 @@
+// Package bridge — MQTT-подписка на телеметрию устройств → shared-SQS.
+//
+// Роль старого mqtt-bridge, но внутри монолита: подключается к EMQX как
+// MQTT-клиент, подписывается на "+/telemetry/+" и шлёт envelope в SQS.
+package bridge
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	mqtt "github.com/eclipse/paho.mqtt.golang"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/config"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/sqsclient"
+)
+
+// telemetryTopicFilter — все namespace, все устройства.
+const telemetryTopicFilter = "+/telemetry/+"
+
+// Run — бесконечный цикл bridge: подключение → подписка → ожидание сигнала завершения.
+func Run(ctx context.Context, cfg *config.Config, sqsClient *sqs.Client, log *slog.Logger) error {
+	log.Info("bridge: starting", "broker", cfg.MQTTBrokerURL, "client_id", cfg.MQTTClientID)
+
+	// URL очереди получаем один раз при старте (как старый consumer).
+	queueURL, err := sqsclient.ResolveQueueURL(ctx, sqsClient, cfg.SQSQueueName)
+	if err != nil {
+		return err
+	}
+	log.Info("bridge: SQS queue resolved", "queue", cfg.SQSQueueName)
+
+	// Обработчик сообщений передаём в connectMQTT: подписка выполняется в
+	// OnConnectHandler, т.е. повторяется при каждом (ре)подключении.
+	// Иначе после потери сессии EMQX бридж оставался бы без подписки
+	// (прецедент 2026-08-16: реконнект без resubscribe → телеметрия терялась).
+	//
+	// Отправка в SQS — через диспатчер (канал + worker-пул): колбэк MQTT
+	// не блокируется сетью (фикс CRITICAL из ревью 2026-08-16).
+	dispatcher := newSQSDispatcher(sqsClient, queueURL, log)
+	dispatcher.start(ctx)
+
+	handler := newMessageHandler(dispatcher, log)
+
+	client, err := connectMQTT(ctx, cfg, log, handler)
+	if err != nil {
+		dispatcher.closeAndWait()
+		return err
+	}
+
+	<-ctx.Done()
+	log.Info("bridge: shutting down")
+	// Порядок: сначала отключить MQTT (источник), затем слить остаток в SQS.
+	client.Disconnect(2000)
+	dispatcher.closeAndWait()
+	return nil
+}
+
+// errSubscribeTimeout — не дождались подтверждения подписки.
+var errSubscribeTimeout = errBridge("MQTT subscribe timeout")
+
+// errBridge — ошибки bridge.
+type errBridge string
+
+func (e errBridge) Error() string { return string(e) }
+
+// connectMQTT устанавливает подключение к EMQX с автореконнектом.
+// handler передаётся в OnConnectHandler: подписка повторяется при каждом подключении.
+func connectMQTT(ctx context.Context, cfg *config.Config, log *slog.Logger, handler mqtt.MessageHandler) (mqtt.Client, error) {
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(cfg.MQTTBrokerURL)
+	opts.SetClientID(cfg.MQTTClientID)
+	opts.SetUsername(cfg.MQTTUsername)
+	opts.SetPassword(cfg.MQTTPassword)
+	opts.SetAutoReconnect(true)
+	opts.SetConnectRetry(true)
+	opts.SetConnectRetryInterval(5 * time.Second)
+	opts.SetKeepAlive(30 * time.Second)
+	opts.SetCleanSession(false)
+
+	opts.SetConnectionLostHandler(func(_ mqtt.Client, err error) {
+		log.Warn("bridge: MQTT connection lost, reconnecting...", "err", err)
+	})
+	opts.SetReconnectingHandler(func(_ mqtt.Client, _ *mqtt.ClientOptions) {
+		log.Info("bridge: MQTT reconnecting...")
+	})
+	opts.SetOnConnectHandler(func(c mqtt.Client) {
+		log.Info("bridge: MQTT connected")
+		token := c.Subscribe(telemetryTopicFilter, 1, handler)
+		if !token.WaitTimeout(10 * time.Second) {
+			log.Error("bridge: resubscribe timeout", "filter", telemetryTopicFilter)
+			c.Disconnect(100) // принудительный реконнект (подписка обязательна)
+			return
+		}
+		if token.Error() != nil {
+			log.Error("bridge: resubscribe failed", "filter", telemetryTopicFilter, "err", token.Error())
+			c.Disconnect(100) // принудительный реконнект (подписка обязательна)
+			return
+		}
+		log.Info("bridge: subscribed", "filter", telemetryTopicFilter)
+	})
+
+	client := mqtt.NewClient(opts)
+	token := client.Connect()
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	case <-time.After(30 * time.Second):
+		return nil, errBridge("bridge: MQTT connect timeout")
+	case <-token.Done():
+	}
+	if token.Error() != nil {
+		return nil, token.Error()
+	}
+	return client, nil
+}

internal/service/bridge/handler.go

@@ -0,0 +1,56 @@
+// handler.go — обработчик MQTT-сообщений: envelope → канал диспатчера SQS.
+//
+// Колбэк НЕ делает сетевых вызовов: только парсинг топика и неблокирующий
+// enqueue. Отправка в SQS — worker-пул sqsDispatcher (см. sender.go).
+package bridge
+
+import (
+	"encoding/json"
+	"log/slog"
+	"strings"
+	"time"
+
+	mqtt "github.com/eclipse/paho.mqtt.golang"
+)
+
+// TelemetryEnvelope — сообщение, перекладываемое в SQS (разбирается consumer).
+type TelemetryEnvelope struct {
+	Namespace  string          `json:"namespace"`
+	DeviceID   string          `json:"device_id"`
+	Topic      string          `json:"topic"`
+	Payload    json.RawMessage `json:"payload"`
+	ReceivedAt string          `json:"received_at"`
+}
+
+// newMessageHandler возвращает обработчик MQTT-сообщений:
+// валидация топика "{namespace}/telemetry/{deviceId}" → enqueue в диспатчер.
+func newMessageHandler(dispatcher *sqsDispatcher, log *slog.Logger) mqtt.MessageHandler {
+	return func(_ mqtt.Client, msg mqtt.Message) {
+		topic := msg.Topic()
+		payload := msg.Payload()
+
+		// Топик: "{namespace}/telemetry/{deviceId}". Пустые части — мусор.
+		parts := strings.SplitN(topic, "/", 3)
+		if len(parts) != 3 || parts[0] == "" || parts[2] == "" || parts[1] != "telemetry" {
+			log.Warn("bridge: unexpected topic format, skipping", "topic", topic)
+			return
+		}
+		ns := parts[0]
+		deviceID := parts[2]
+
+		// Не-JSON payload оборачиваем в строку.
+		rawPayload := json.RawMessage(payload)
+		if !json.Valid(payload) {
+			quoted, _ := json.Marshal(string(payload))
+			rawPayload = json.RawMessage(quoted)
+		}
+
+		dispatcher.enqueue(TelemetryEnvelope{
+			Namespace:  ns,
+			DeviceID:   deviceID,
+			Topic:      topic,
+			Payload:    rawPayload,
+			ReceivedAt: time.Now().UTC().Format(time.RFC3339),
+		})
+	}
+}

internal/service/bridge/sender.go

@@ -0,0 +1,145 @@
+// sender.go — асинхронная отправка envelope в SQS из бриджа.
+//
+// Мотивация (Sonnet-ревью 2026-08-16, находка CRITICAL): SendMessage был
+// синхронным внутри MQTT-колбэка paho. При недоступности SQS (таймаут ~30с)
+// блокировался приём ВСЕХ MQTT-сообщений → потери телеметрии.
+//
+// Теперь: колбэк кладёт envelope в буферизованный канал НЕблокирующе
+// (переполнение — дроп со счётчиком), worker-пул отправляет в SQS с
+// ограниченными ретраями и backoff.
+package bridge
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+)
+
+// Константы диспатчера.
+const (
+	// dispatcherQueueSize — буфер envelope перед SQS (~100 msg/s * 100с буфера).
+	dispatcherQueueSize = 10000
+	// dispatcherWorkers — горутин, отправляющих в SQS.
+	dispatcherWorkers = 4
+	// sendMaxAttempts — попыток SendMessage на одно сообщение.
+	sendMaxAttempts = 3
+
+	// maxSQSBodyBytes — потолок размера envelope для SQS.
+	// SQS (и shared-sqs) режут сообщения >256KB — запас на оверхед.
+	maxSQSBodyBytes = 250 * 1024
+)
+
+// sqsDispatcher — канал + worker-пул для отправки в SQS.
+type sqsDispatcher struct {
+	ch       chan TelemetryEnvelope
+	client   *sqs.Client
+	queueURL string
+	log      *slog.Logger
+	wg       sync.WaitGroup
+	dropped  atomic.Int64
+}
+
+// newSQSDispatcher создаёт диспатчер. start() запускает worker-пул.
+func newSQSDispatcher(client *sqs.Client, queueURL string, log *slog.Logger) *sqsDispatcher {
+	return &sqsDispatcher{
+		ch:       make(chan TelemetryEnvelope, dispatcherQueueSize),
+		client:   client,
+		queueURL: queueURL,
+		log:      log,
+	}
+}
+
+// start запускает worker-пул.
+func (d *sqsDispatcher) start(ctx context.Context) {
+	for i := 0; i < dispatcherWorkers; i++ {
+		d.wg.Add(1)
+		go func(wid int) {
+			defer d.wg.Done()
+			d.worker(ctx, wid)
+		}(i)
+	}
+}
+
+// enqueue кладёт envelope в канал НЕблокирующе. false = буфер полон (дроп).
+func (d *sqsDispatcher) enqueue(e TelemetryEnvelope) bool {
+	select {
+	case d.ch <- e:
+		return true
+	default:
+		n := d.dropped.Add(1)
+		if n%100 == 1 {
+			d.log.Error("bridge: SQS dispatch queue full, dropping",
+				"namespace", e.Namespace, "device", e.DeviceID,
+				"dropped_total", n)
+		}
+		return false
+	}
+}
+
+// closeAndWait закрывает канал и ждёт завершения worker'ов (flush).
+func (d *sqsDispatcher) closeAndWait() {
+	close(d.ch)
+	d.wg.Wait()
+	d.log.Info("bridge: SQS dispatcher stopped", "dropped_total", d.dropped.Load())
+}
+
+// worker — цикл отправки из канала с ограниченными ретраями.
+func (d *sqsDispatcher) worker(ctx context.Context, wid int) {
+	for e := range d.ch {
+		body, err := json.Marshal(e)
+		if err != nil {
+			d.log.Error("bridge: marshal envelope", "worker", wid,
+				"namespace", e.Namespace, "err", err)
+			continue
+		}
+		if len(body) > maxSQSBodyBytes {
+			// Лимит SQS 256KB — такие сообщения не пройдут в принципе
+			// (проверено 2026-08-16: InvalidParameterValue message size
+			// exceeds the limit). Дроп с явным логом.
+			d.log.Error("bridge: payload too large for SQS, dropping",
+				"worker", wid, "namespace", e.Namespace,
+				"device", e.DeviceID, "bytes", len(body),
+				"limit_bytes", maxSQSBodyBytes)
+			continue
+		}
+		if err := d.sendWithRetry(ctx, string(body)); err != nil {
+			d.log.Error("bridge: SQS send failed after retries, dropping",
+				"worker", wid, "namespace", e.Namespace,
+				"device", e.DeviceID, "err", err)
+		}
+	}
+}
+
+// sendWithRetry — SendMessage с backoff 1с/2с/4с.
+func (d *sqsDispatcher) sendWithRetry(ctx context.Context, body string) error {
+	var lastErr error
+	backoff := time.Second
+	for attempt := 1; attempt <= sendMaxAttempts; attempt++ {
+		_, err := d.client.SendMessage(ctx, &sqs.SendMessageInput{
+			QueueUrl:    aws.String(d.queueURL),
+			MessageBody: aws.String(body),
+		})
+		if err == nil {
+			return nil
+		}
+		lastErr = err
+		if ctx.Err() != nil {
+			return lastErr
+		}
+		if attempt < sendMaxAttempts {
+			select {
+			case <-ctx.Done():
+				return lastErr
+			case <-time.After(backoff):
+			}
+			backoff *= 2
+		}
+	}
+	return lastErr
+}

internal/service/config/config.go

@@ -0,0 +1,157 @@
+// Package config — конфигурация монолита iot-service из env-переменных.
+//
+// Принцип: несекретные значения имеют дефолты (продублированы ENV в Dockerfile),
+// секреты — обязательны и задаются в deck-UI при создании контейнера.
+// Env-переменные после деплоя не меняются — поэтому дефолты вшиты в образ.
+package config
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// Config — вся конфигурация iot-service.
+type Config struct {
+	// HTTP API
+	APIPort string
+
+	// PostgreSQL (managed, общий для устройств и телеметрии)
+	IOTPGDSN string
+
+	// shared-SQS
+	SQSEndpoint  string
+	SQSAccessKey string
+	SQSSecretKey string
+	SQSQueueName string
+	SQSRegion    string
+
+	// SQS-потребитель
+	SQSLongPollSeconds   int
+	SQSVisibilityTimeout int
+
+	// MQTT (EMQX)
+	MQTTBrokerURL string
+	MQTTUsername  string
+	MQTTPassword  string
+	MQTTClientID  string
+
+	// Админ-статистика
+	AdminStatsToken string
+
+	// Безопасность
+	AuthTestMode bool
+	// JwtHMACSecret — если задан, JWT проверяется по HS256 (HMAC-SHA256).
+	// Пусто — структурная проверка (как раньше, периметр = платформа).
+	JwtHMACSecret string
+
+	// Логирование
+	LogLevel slog.Level
+}
+
+// getEnv возвращает значение env или дефолт.
+func getEnv(key, def string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return def
+}
+
+// getEnvInt возвращает целое значение env или дефолт (неположительное — дефолт).
+func getEnvInt(key string, def int) int {
+	if v := os.Getenv(key); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 {
+			return n
+		}
+	}
+	return def
+}
+
+// getEnvBool разбирает булево значение env.
+func getEnvBool(key string, def bool) bool {
+	v := os.Getenv(key)
+	if v == "" {
+		return def
+	}
+	switch strings.ToLower(v) {
+	case "1", "true", "yes", "on":
+		return true
+	case "0", "false", "no", "off":
+		return false
+	default:
+		return def
+	}
+}
+
+// parseLogLevel разбирает уровень логирования.
+func parseLogLevel(v string, def slog.Level) slog.Level {
+	switch strings.ToLower(v) {
+	case "debug":
+		return slog.LevelDebug
+	case "warn", "warning":
+		return slog.LevelWarn
+	case "error":
+		return slog.LevelError
+	default:
+		return def
+	}
+}
+
+// Load читает конфигурацию из env, подставляет дефолты
+// и проверяет обязательные (секретные) переменные.
+func Load() (*Config, error) {
+	cfg := &Config{
+		APIPort:              getEnv("API_PORT", DefaultAPIPort),
+		IOTPGDSN:             os.Getenv("IOT_PG_DSN"),
+		SQSEndpoint:          getEnv("SQS_ENDPOINT", DefaultSQSEndpoint),
+		SQSAccessKey:         os.Getenv("SQS_ACCESS_KEY"),
+		SQSSecretKey:         os.Getenv("SQS_SECRET_KEY"),
+		SQSQueueName:         getEnv("SQS_QUEUE_NAME", DefaultSQSQueueName),
+		SQSRegion:            getEnv("SQS_REGION", DefaultSQSRegion),
+		SQSLongPollSeconds:   getEnvInt("SQS_LONG_POLL_SECONDS", 20),
+		SQSVisibilityTimeout: getEnvInt("SQS_VISIBILITY_TIMEOUT", 120),
+		MQTTUsername:         os.Getenv("MQTT_USERNAME"),
+		MQTTPassword:         os.Getenv("MQTT_PASSWORD"),
+		MQTTClientID:         getEnv("MQTT_CLIENT_ID", DefaultMQTTClientID),
+		AdminStatsToken:      os.Getenv("ADMIN_STATS_TOKEN"),
+		AuthTestMode:         getEnvBool("AUTH_TEST_MODE", false),
+		JwtHMACSecret:        os.Getenv("JWT_HMAC_SECRET"),
+		LogLevel:             parseLogLevel(os.Getenv("LOG_LEVEL"), slog.LevelInfo),
+	}
+
+	// MQTT broker URL: либо полный MQTT_BROKER_URL, либо из HOST/PORT/WS_PATH
+	cfg.MQTTBrokerURL = os.Getenv("MQTT_BROKER_URL")
+	if cfg.MQTTBrokerURL == "" {
+		host := getEnv("MQTT_HOST", DefaultMQTTHost)
+		port := getEnv("MQTT_PORT", DefaultMQTTPort)
+		path := getEnv("MQTT_WS_PATH", DefaultMQTTWSPath)
+		cfg.MQTTBrokerURL = "ws://" + host + ":" + port + path
+	} else if !strings.HasPrefix(cfg.MQTTBrokerURL, "ws://") &&
+		!strings.HasPrefix(cfg.MQTTBrokerURL, "wss://") {
+		return nil, fmt.Errorf("MQTT_BROKER_URL must start with ws:// or wss://, got %q", cfg.MQTTBrokerURL)
+	}
+
+	var missing []string
+	if cfg.IOTPGDSN == "" {
+		missing = append(missing, "IOT_PG_DSN")
+	}
+	if cfg.SQSAccessKey == "" {
+		missing = append(missing, "SQS_ACCESS_KEY")
+	}
+	if cfg.SQSSecretKey == "" {
+		missing = append(missing, "SQS_SECRET_KEY")
+	}
+	if cfg.MQTTUsername == "" {
+		missing = append(missing, "MQTT_USERNAME")
+	}
+	if cfg.MQTTPassword == "" {
+		missing = append(missing, "MQTT_PASSWORD")
+	}
+	if len(missing) > 0 {
+		return nil, fmt.Errorf("required env vars not set: %s", strings.Join(missing, ", "))
+	}
+
+	return cfg, nil
+}

internal/service/config/defaults.go

@@ -0,0 +1,32 @@
+package config
+
+// Defaults — дефолтные значения env-переменных (не секреты).
+// Продублированы в Dockerfile ENV.
+const (
+	// DefaultAPIPort — единственный порт контейнера: API + /health + /metrics.
+	DefaultAPIPort = "9090"
+
+	// DefaultSQSEndpoint — внутренний адрес shared-sqs в том же кластере Nubes.
+	// Обходит внешний шлюз платформы (таймауты 31-33с, MSS 1448, ~150с).
+	DefaultSQSEndpoint = "http://containerk8s.f1ffb134-7d16-45bd-8bef-69f6ec8ab33c.svc.cluster.local:4100"
+
+	// DefaultSQSQueueName — очередь телеметрии IoT.
+	DefaultSQSQueueName = "iot-telemetry"
+
+	// DefaultSQSRegion — регион для self-hosted SQS (не важен, оставлен для SDK).
+	DefaultSQSRegion = "us-east-1"
+
+	// DefaultMQTTHost — внутреннее имя EMQX-контейнера на платформе.
+	// Реальный UUID namespace EMQX задаётся в deck-UI (MQTT_HOST) при создании.
+	DefaultMQTTHost = "emqx"
+
+	// DefaultMQTTPort — WebSocket-листенер EMQX (wss внутри платформы).
+	DefaultMQTTPort = "8083"
+
+	// DefaultMQTTWSPath — путь MQTT-over-WebSocket на EMQX.
+	DefaultMQTTWSPath = "/mqtt"
+
+	// DefaultMQTTClientID — clientID bridge-подключения к EMQX.
+	// Используется и в ACL-логике MQTT-auth.
+	DefaultMQTTClientID = "iot-bridge"
+)

internal/service/consumer/consumer.go

@@ -0,0 +1,108 @@
+// Package consumer — чтение shared-SQS → per-tenant PostgreSQL.
+//
+// Роль старого sqs-consumer внутри монолита: long-poll цикл, обработка
+// envelope телеметрии, DeleteMessage после успешной записи (at-least-once).
+package consumer
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/config"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/sqsclient"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+)
+
+// errorBackoff — пауза между попытками при ошибках SQS.
+const errorBackoff = 5 * time.Second
+
+// maxProcessBackoff — потолок backoff после ошибок обработки (PG).
+const maxProcessBackoff = 60 * time.Second
+
+// Run — бесконечный long-poll цикл потребителя.
+func Run(ctx context.Context, cfg *config.Config, sqsClient *sqs.Client, store *iotpg.IoTPostgresStore, log *slog.Logger) error {
+	queueURL, err := sqsclient.ResolveQueueURL(ctx, sqsClient, cfg.SQSQueueName)
+	if err != nil {
+		return err
+	}
+	log.Info("consumer: SQS queue resolved", "queue", cfg.SQSQueueName)
+
+	for {
+		if ctx.Err() != nil {
+			break
+		}
+
+		resp, err := sqsClient.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
+			QueueUrl:            aws.String(queueURL),
+			MaxNumberOfMessages: 10,
+			WaitTimeSeconds:     int32(cfg.SQSLongPollSeconds),
+			VisibilityTimeout:   int32(cfg.SQSVisibilityTimeout),
+		})
+		if err != nil {
+			if ctx.Err() != nil {
+				break
+			}
+			log.Error("consumer: ReceiveMessage failed", "err", err)
+			if !sleepCtx(ctx, errorBackoff) {
+				break
+			}
+			continue
+		}
+
+		processBackoff := time.Second
+		for _, msg := range resp.Messages {
+			if msg.Body == nil || *msg.Body == "" {
+				log.Warn("consumer: empty message body, deleting",
+					"message_id", aws.ToString(msg.MessageId))
+				if err := deleteMessage(ctx, sqsClient, queueURL, msg.ReceiptHandle, log); err != nil {
+					log.Error("consumer: DeleteMessage failed", "err", err, "message_id", aws.ToString(msg.MessageId))
+				}
+				continue
+			}
+			if err := processTelemetry(ctx, *msg.Body, store, log); err != nil {
+				log.Error("consumer: process telemetry", "err", err, "message_id", aws.ToString(msg.MessageId))
+				// Сообщение вернётся в очередь после visibility timeout.
+				// Backoff с jitter — не долбить упавший PG в цикле
+				// (фикс HIGH из ревью 2026-08-16: лавина ретраев).
+				if !sleepCtx(ctx, processBackoff) {
+					break
+				}
+				processBackoff *= 2
+				if processBackoff > maxProcessBackoff {
+					processBackoff = maxProcessBackoff
+				}
+				continue
+			}
+			processBackoff = time.Second
+			if err := deleteMessage(ctx, sqsClient, queueURL, msg.ReceiptHandle, log); err != nil {
+				log.Error("consumer: DeleteMessage failed", "err", err, "message_id", aws.ToString(msg.MessageId))
+			}
+		}
+	}
+
+	log.Info("consumer: shutting down")
+	return nil
+}
+
+// deleteMessage удаляет обработанное сообщение из очереди.
+func deleteMessage(ctx context.Context, client *sqs.Client, queueURL string, receiptHandle *string, log *slog.Logger) error {
+	_, err := client.DeleteMessage(ctx, &sqs.DeleteMessageInput{
+		QueueUrl:      aws.String(queueURL),
+		ReceiptHandle: receiptHandle,
+	})
+	return err
+}
+
+// sleepCtx — ожидание с прерыванием по ctx. false = ctx завершён.
+func sleepCtx(ctx context.Context, d time.Duration) bool {
+	select {
+	case <-ctx.Done():
+		return false
+	case <-time.After(d):
+		return true
+	}
+}

internal/service/consumer/processor.go

@@ -0,0 +1,35 @@
+// processor.go — разбор envelope телеметрии и запись в per-tenant PostgreSQL.
+package consumer
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/bridge"
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/storage/iotpg"
+)
+
+// processTelemetry десериализует envelope и пишет в tenant DB.
+// Битый JSON — пропускаем (не блокируем очередь).
+func processTelemetry(ctx context.Context, body string, store *iotpg.IoTPostgresStore, log *slog.Logger) error {
+	var envelope bridge.TelemetryEnvelope
+	if err := json.Unmarshal([]byte(body), &envelope); err != nil {
+		log.Warn("consumer: failed to unmarshal envelope, skipping", "err", err)
+		return nil
+	}
+
+	// EnsureTenantDB идемпотентен, кэшируется после первого вызова.
+	if err := store.EnsureTenantDB(ctx, envelope.Namespace); err != nil {
+		return err
+	}
+	if err := store.InsertTelemetry(ctx, envelope.Namespace, envelope.DeviceID, envelope.Payload); err != nil {
+		return err
+	}
+
+	log.Info("consumer: telemetry saved",
+		"namespace", envelope.Namespace,
+		"device", envelope.DeviceID,
+	)
+	return nil
+}

internal/service/sqsclient/sqsclient.go

@@ -0,0 +1,38 @@
+// Package sqsclient — общий фабричный клиент shared-SQS для монолита.
+//
+// Используют: bridge (SendMessage), consumer (ReceiveMessage/DeleteMessage),
+// admin-stats (GetQueueUrl/GetQueueAttributes).
+package sqsclient
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+
+	"gitea.services.ngcloud.ru/Nail/IoT/internal/service/config"
+)
+
+// New создаёт SQS-клиент с переопределённым endpoint (self-hosted shared-sqs).
+func New(cfg *config.Config) *sqs.Client {
+	return sqs.New(sqs.Options{
+		Region: cfg.SQSRegion,
+		Credentials: credentials.NewStaticCredentialsProvider(
+			cfg.SQSAccessKey, cfg.SQSSecretKey, "",
+		),
+		BaseEndpoint: aws.String(cfg.SQSEndpoint),
+	})
+}
+
+// ResolveQueueURL получает URL очереди по имени (один вызов при старте).
+func ResolveQueueURL(ctx context.Context, client *sqs.Client, queueName string) (string, error) {
+	out, err := client.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
+		QueueName: aws.String(queueName),
+	})
+	if err != nil {
+		return "", fmt.Errorf("sqs: GetQueueUrl %q: %w", queueName, err)
+	}
+	return aws.ToString(out.QueueUrl), nil
+}

internal/service/store/bridge.go

@@ -0,0 +1,32 @@
+package store
+
+import (
+	"context"
+	"fmt"
+)
+
+// bridgeNamespace — служебный namespace строки бриджа в iot_devices.
+// EMQX (postgres auth/ACL) узнаёт бридж по условию
+// namespace = '__bridge' AND username = device_id.
+const bridgeNamespace = "__bridge"
+
+// EnsureBridgeDevice создаёт (или обновляет) служебную строку бриджа в
+// iot_devices. EMQX авторизует MQTT-подключение бриджа по этой строке,
+// поэтому device_id = MQTT username (iot-bridge), пароль = MQTT_PASSWORD.
+//
+// Нужно для PG-auth EMQX (хвост 3): EMQX зависит только от PostgreSQL,
+// монолит при старте гарантирует наличие строки бриджа.
+func (s *DeviceStore) EnsureBridgeDevice(ctx context.Context, username, password string) error {
+	_, err := s.db.ExecContext(ctx, `
+INSERT INTO iot_devices (namespace, name, device_id, enabled, mqtt_password, metadata, phase)
+VALUES ($1, $2, $3, true, $4, '{}'::jsonb, 'Active')
+ON CONFLICT (namespace, name) DO UPDATE
+  SET device_id     = EXCLUDED.device_id,
+      enabled       = true,
+      mqtt_password = EXCLUDED.mqtt_password`,
+		bridgeNamespace, "iot-bridge", username, password)
+	if err != nil {
+		return fmt.Errorf("store: ensure bridge device: %w", err)
+	}
+	return nil
+}

internal/service/store/device.go

@@ -0,0 +1,29 @@
+// Package store — хранилище устройств IoT в PostgreSQL.
+//
+// Таблица iot_devices заменяет CRD IoTDevice и k8s Secrets старого IoT.
+// Устройства: namespace, name, device_id, enabled, mqtt_password, metadata.
+package store
+
+import (
+	"errors"
+	"time"
+)
+
+// ErrNotFound — устройство не найдено.
+var ErrNotFound = errors.New("device not found")
+
+// ErrAlreadyExists — конфликт уникальности (namespace, name) или (namespace, device_id).
+var ErrAlreadyExists = errors.New("device already exists")
+
+// Device — устройство IoT из таблицы iot_devices.
+type Device struct {
+	Namespace     string
+	Name          string
+	DeviceID      string
+	Enabled       bool
+	MQTTPassword  string
+	Metadata      map[string]string
+	Phase         string
+	LastConnected *time.Time
+	CreatedAt     time.Time
+}

internal/service/store/devices.go

@@ -0,0 +1,183 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+// Create вставляет новое устройство. Конфликт (namespace, name) или
+// (namespace, device_id) возвращает ErrAlreadyExists.
+func (s *DeviceStore) Create(ctx context.Context, d *Device) error {
+	metadata, err := json.Marshal(d.Metadata)
+	if err != nil {
+		return fmt.Errorf("store: marshal metadata: %w", err)
+	}
+	_, err = s.db.ExecContext(ctx, `
+INSERT INTO iot_devices (namespace, name, device_id, enabled, mqtt_password, metadata)
+VALUES ($1, $2, $3, $4, $5, $6)`,
+		d.Namespace, d.Name, d.DeviceID, d.Enabled, d.MQTTPassword, metadata,
+	)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return ErrAlreadyExists
+		}
+		return fmt.Errorf("store: insert device: %w", err)
+	}
+	return nil
+}
+
+// List возвращает устройства namespace (без паролей — API их не отдаёт).
+// limit <= 0 — без ограничения; offset — смещение (пагинация API).
+func (s *DeviceStore) List(ctx context.Context, namespace string, limit, offset int) ([]Device, error) {
+	query := `SELECT namespace, name, device_id, enabled, mqtt_password, metadata, phase,
+       last_connected, created_at
+FROM iot_devices WHERE namespace = $1 ORDER BY name`
+	args := []any{namespace}
+	if limit > 0 {
+		query += fmt.Sprintf(" LIMIT $%d", len(args)+1)
+		args = append(args, limit)
+	}
+	if offset > 0 {
+		query += fmt.Sprintf(" OFFSET $%d", len(args)+1)
+		args = append(args, offset)
+	}
+	rows, err := s.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("store: list devices: %w", err)
+	}
+	defer rows.Close()
+	return scanDevices(rows)
+}
+
+// GetByName возвращает устройство по (namespace, name).
+func (s *DeviceStore) GetByName(ctx context.Context, namespace, name string) (*Device, error) {
+	return s.get(ctx, `SELECT namespace, name, device_id, enabled, mqtt_password, metadata, phase,
+       last_connected, created_at
+FROM iot_devices WHERE namespace = $1 AND name = $2`, namespace, name)
+}
+
+// GetByDeviceID возвращает устройство по (namespace, device_id) — для MQTT auth.
+func (s *DeviceStore) GetByDeviceID(ctx context.Context, namespace, deviceID string) (*Device, error) {
+	return s.get(ctx, `SELECT namespace, name, device_id, enabled, mqtt_password, metadata, phase,
+       last_connected, created_at
+FROM iot_devices WHERE namespace = $1 AND device_id = $2`, namespace, deviceID)
+}
+
+// get — общая выборка одного устройства.
+func (s *DeviceStore) get(ctx context.Context, query string, args ...any) (*Device, error) {
+	d, err := scanDevice(s.db.QueryRowContext(ctx, query, args...))
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("store: get device: %w", err)
+	}
+	return d, nil
+}
+
+// UpdateEnabled включает/выключает устройство.
+func (s *DeviceStore) UpdateEnabled(ctx context.Context, namespace, name string, enabled bool) error {
+	res, err := s.db.ExecContext(ctx,
+		`UPDATE iot_devices SET enabled = $3, phase = $4
+         WHERE namespace = $1 AND name = $2`,
+		namespace, name, enabled, phaseOf(enabled))
+	if err != nil {
+		return fmt.Errorf("store: update device: %w", err)
+	}
+	if n, _ := res.RowsAffected(); n == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// Delete удаляет устройство.
+func (s *DeviceStore) Delete(ctx context.Context, namespace, name string) error {
+	res, err := s.db.ExecContext(ctx,
+		`DELETE FROM iot_devices WHERE namespace = $1 AND name = $2`, namespace, name)
+	if err != nil {
+		return fmt.Errorf("store: delete device: %w", err)
+	}
+	if n, _ := res.RowsAffected(); n == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// TouchLastConnected обновляет last_connected (best-effort при MQTT auth).
+func (s *DeviceStore) TouchLastConnected(ctx context.Context, namespace, deviceID string) {
+	_, _ = s.db.ExecContext(ctx, `
+UPDATE iot_devices SET last_connected = now()
+WHERE namespace = $1 AND device_id = $2`, namespace, deviceID)
+}
+
+// Count возвращает количество устройств в namespace (для админ-статистики).
+func (s *DeviceStore) Count(ctx context.Context, namespace string) (int64, error) {
+	var n int64
+	err := s.db.QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM iot_devices WHERE namespace = $1`, namespace).Scan(&n)
+	if err != nil {
+		return 0, fmt.Errorf("store: count devices: %w", err)
+	}
+	return n, nil
+}
+
+// scanDevices читает все строки результата.
+func scanDevices(rows *sql.Rows) ([]Device, error) {
+	var out []Device
+	for rows.Next() {
+		d, err := scanDevice(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, *d)
+	}
+	return out, rows.Err()
+}
+
+// scanDevice читает одну строку устройства.
+type rowScanner interface {
+	Scan(dest ...any) error
+}
+
+func scanDevice(r rowScanner) (*Device, error) {
+	var (
+		d        Device
+		metadata []byte
+		lastConn sql.NullTime
+	)
+	err := r.Scan(&d.Namespace, &d.Name, &d.DeviceID, &d.Enabled, &d.MQTTPassword,
+		&metadata, &d.Phase, &lastConn, &d.CreatedAt)
+	if err != nil {
+		return nil, err
+	}
+	if len(metadata) > 0 {
+		_ = json.Unmarshal(metadata, &d.Metadata)
+	}
+	if lastConn.Valid {
+		t := lastConn.Time
+		d.LastConnected = &t
+	}
+	return &d, nil
+}
+
+// phaseOf — статус устройства в зависимости от enabled.
+func phaseOf(enabled bool) string {
+	if enabled {
+		return "Active"
+	}
+	return "Disabled"
+}
+
+// isUniqueViolation определяет нарушение уникальности PostgreSQL.
+func isUniqueViolation(err error) bool {
+	return err != nil && err.Error() != "" && hasSQLState(err, "23505")
+}
+
+func hasSQLState(err error, state string) bool {
+	type stater interface{ SQLState() string }
+	var e stater
+	return errors.As(err, &e) && e.SQLState() == state
+}

internal/service/store/open.go

@@ -0,0 +1,72 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"os"
+	"strconv"
+	"time"
+)
+
+// schemaSQL — схема таблицы устройств.
+// PRIMARY KEY (namespace, name) — как в REST-маршруте /devices/{name}.
+// Уникальность device_id в рамках namespace — для MQTT username.
+const schemaSQL = `
+CREATE TABLE IF NOT EXISTS iot_devices (
+  namespace      TEXT        NOT NULL,
+  name           TEXT        NOT NULL,
+  device_id      TEXT        NOT NULL,
+  enabled        BOOLEAN     NOT NULL DEFAULT true,
+  mqtt_password  TEXT        NOT NULL,
+  metadata       JSONB,
+  phase          TEXT        NOT NULL DEFAULT 'Active',
+  last_connected TIMESTAMPTZ,
+  created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (namespace, name)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_iot_devices_ns_device
+  ON iot_devices (namespace, device_id);
+`
+
+// DeviceStore — доступ к таблице iot_devices (собственный пул соединений).
+type DeviceStore struct {
+	db *sql.DB
+}
+
+// Open подключается к PostgreSQL по DSN и инициализирует схему.
+func Open(ctx context.Context, dsn string) (*DeviceStore, error) {
+	db, err := sql.Open("postgres", dsn)
+	if err != nil {
+		return nil, fmt.Errorf("store: open DB: %w", err)
+	}
+	// Пул устройств: дефолт 20 (ревью 2026-08-16: 5 мало для API+MQTT auth),
+	// переопределяется IOT_PG_MAX_CONNS.
+	maxConns := 20
+	if v := os.Getenv("IOT_PG_MAX_CONNS"); v != "" {
+		if n, convErr := strconv.Atoi(v); convErr == nil && n > 0 {
+			maxConns = n
+		}
+	}
+	db.SetMaxOpenConns(maxConns)
+	db.SetMaxIdleConns(2)
+	db.SetConnMaxLifetime(5 * time.Minute)
+
+	pingCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	if err := db.PingContext(pingCtx); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("store: ping DB: %w", err)
+	}
+	if _, err := db.ExecContext(ctx, schemaSQL); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("store: init schema: %w", err)
+	}
+	return &DeviceStore{db: db}, nil
+}
+
+// Close закрывает пул соединений.
+func (s *DeviceStore) Close() error {
+	return s.db.Close()
+}

internal/storage/iotpg/iot_telemetry_store.go

@@ -37,9 +37,29 @@ type IoTPostgresStore struct {
 	adminDB  *sql.DB
 	adminDSN string
 	tenants  sync.Map
+	tenantMu sync.Map // namespace → *sync.Mutex (дедупликация открытия)
+	ensured  sync.Map // namespace → struct{} (EnsureTenantDB уже выполнен)
 	log      *slog.Logger
+
+	// батчинг вставок (фикс MEDIUM ревью 2026-08-16: 1000 msg/s = 1000 INSERT)
+	mu        sync.Mutex
+	batches   map[string][]telemetryInsert
+	stopFlush chan struct{}
+	flushWG   sync.WaitGroup
 }
 
+// telemetryInsert — строка для батч-вставки.
+type telemetryInsert struct {
+	deviceID string
+	payload  []byte
+}
+
+// telemetryBatchSize — размер батча перед синхронным flush.
+const telemetryBatchSize = 100
+
+// telemetryFlushInterval — период фонового flush неполных батчей.
+const telemetryFlushInterval = 200 * time.Millisecond
+
 // TelemetryRow — одна запись телеметрии из таблицы iot_telemetry.
 type TelemetryRow struct {
 	ID       int64           `json:"id"`
@@ -60,19 +80,90 @@ func New(adminDSN string, log *slog.Logger) (*IoTPostgresStore, error) {
 		db.Close()
 		return nil, fmt.Errorf("iotpg: ping admin DB: %w", err)
 	}
-	db.SetMaxOpenConns(5)
+	db.SetMaxOpenConns(10)
 	db.SetMaxIdleConns(2)
 	db.SetConnMaxLifetime(5 * time.Minute)
 
-	store := &IoTPostgresStore{adminDB: db, adminDSN: adminDSN, log: log}
+	store := &IoTPostgresStore{
+		adminDB:   db,
+		adminDSN:  adminDSN,
+		batches:   make(map[string][]telemetryInsert),
+		stopFlush: make(chan struct{}),
+		log:       log,
+	}
 	if err := store.initManagementSchema(ctx); err != nil {
 		db.Close()
 		return nil, fmt.Errorf("iotpg: init management schema: %w", err)
 	}
+	store.startFlusher()
 	log.Info("iotpg: connected to IoT Postgres management DB")
 	return store, nil
 }
 
+// startFlusher — фоновая горутина периодического flush неполных батчей.
+func (s *IoTPostgresStore) startFlusher() {
+	s.flushWG.Add(1)
+	go func() {
+		defer s.flushWG.Done()
+		t := time.NewTicker(telemetryFlushInterval)
+		defer t.Stop()
+		for {
+			select {
+			case <-s.stopFlush:
+				return
+			case <-t.C:
+				s.flushAll(false)
+			}
+		}
+	}()
+}
+
+// flushAll — flush всех накопленных батчей. reportErr=false: только лог.
+func (s *IoTPostgresStore) flushAll(reportErr bool) error {
+	s.mu.Lock()
+	if len(s.batches) == 0 {
+		s.mu.Unlock()
+		return nil
+	}
+	batches := s.batches
+	s.batches = make(map[string][]telemetryInsert)
+	s.mu.Unlock()
+
+	var firstErr error
+	for ns, rows := range batches {
+		if err := s.flushTenant(ns, rows); err != nil {
+			s.log.Error("iotpg: flush batch", "namespace", ns, "rows", len(rows), "err", err)
+			if firstErr == nil {
+				firstErr = err
+			}
+		}
+	}
+	return firstErr
+}
+
+// flushTenant — INSERT батча строк одного тенанта (multi-VALUES).
+func (s *IoTPostgresStore) flushTenant(ns string, rows []telemetryInsert) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	tenantDB, err := s.getTenantDB(ctx, ns)
+	if err != nil {
+		return err
+	}
+	// INSERT INTO iot_telemetry (device_id, payload) VALUES ($1,$2),($3,$4),...
+	var sb strings.Builder
+	sb.WriteString("INSERT INTO iot_telemetry (device_id, payload) VALUES ")
+	args := make([]any, 0, len(rows)*2)
+	for i, r := range rows {
+		if i > 0 {
+			sb.WriteString(",")
+		}
+		sb.WriteString(fmt.Sprintf("($%d,$%d)", i*2+1, i*2+2))
+		args = append(args, r.deviceID, r.payload)
+	}
+	_, err = tenantDB.ExecContext(ctx, sb.String(), args...)
+	return err
+}
+
 // NewFromEnv создаёт store из env var IOT_PG_DSN.
 // Возвращает (nil, nil) если переменная не задана — IoT Postgres опционален.
 func NewFromEnv(log *slog.Logger) (*IoTPostgresStore, error) {
@@ -97,9 +188,12 @@ created_at  TIMESTAMPTZ DEFAULT now()
 }
 
 // EnsureTenantDB создаёт DATABASE, USER и таблицу iot_telemetry для namespace.
-// Идемпотентен — повторный вызов безопасен.
+// Идемпотентен — повторный вызов безопасен (кэш ensured пропускает проверки).
-// Вызывается mqtt-bridge при первом сообщении от нового tenant.
 func (s *IoTPostgresStore) EnsureTenantDB(ctx context.Context, namespace string) error {
+	if _, ok := s.ensured.Load(namespace); ok {
+		return nil
+	}
+
 	dbName := tenantDBName(namespace)
 	userName := dbName
 
@@ -114,21 +208,39 @@ func (s *IoTPostgresStore) EnsureTenantDB(ctx context.Context, namespace string)
 	if !exists {
 		password := uuid.New().String()
 
-		// CREATE USER через DO block — pg не поддерживает CREATE USER IF NOT EXISTS
+		// Роль создаём только если её нет (DO-блоки НЕ принимают параметры —
-		_, err = s.adminDB.ExecContext(ctx, fmt.Sprintf(
+		// прецедент 2026-08-16: "got 2 parameters but the statement requires 0").
-			`DO $$ BEGIN
+		var roleExists bool
-                IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = '%s') THEN
+		err = s.adminDB.QueryRowContext(ctx,
-                    CREATE USER %s WITH PASSWORD '%s';
+			`SELECT EXISTS(SELECT 1 FROM pg_roles WHERE rolname = $1)`, userName,
-                END IF;
+		).Scan(&roleExists)
-            END $$`, userName, userName, password,
-		))
 		if err != nil {
-			return fmt.Errorf("iotpg: create user %s: %w", userName, err)
+			return fmt.Errorf("iotpg: check role %s: %w", userName, err)
+		}
+		if !roleExists {
+			_, err = s.adminDB.ExecContext(ctx,
+				`CREATE USER `+pq.QuoteIdentifier(userName)+` WITH PASSWORD `+pq.QuoteLiteral(password),
+			)
+			if err != nil {
+				var pqErr *pq.Error
+				if errors.As(err, &pqErr) && pqErr.Code == "42710" { // duplicate_object
+					// гонка: роль создал параллельный вызов — ок
+				} else {
+					return fmt.Errorf("iotpg: create user %s: %w", userName, err)
+				}
+			}
+		}
+
+		// PG15+: GRANT role TO current_user перед CREATE DATABASE ... OWNER
+		if _, err = s.adminDB.ExecContext(ctx,
+			`GRANT `+pq.QuoteIdentifier(userName)+` TO CURRENT_USER`,
+		); err != nil {
+			return fmt.Errorf("iotpg: grant role %s: %w", userName, err)
 		}
 
 		// CREATE DATABASE нельзя в транзакции
 		if _, err = s.adminDB.ExecContext(ctx,
-			fmt.Sprintf(`CREATE DATABASE %s OWNER %s`, dbName, userName),
+			`CREATE DATABASE `+pq.QuoteIdentifier(dbName)+` OWNER `+pq.QuoteIdentifier(userName),
 		); err != nil {
 			return fmt.Errorf("iotpg: create database %s: %w", dbName, err)
 		}
@@ -158,32 +270,50 @@ payload   JSONB       NOT NULL
 CREATE INDEX IF NOT EXISTS idx_iot_telemetry_device_ts
 ON iot_telemetry (device_id, ts DESC);
 `)
-	return err
+	if err != nil {
+		return err
+	}
+	s.ensured.Store(namespace, struct{}{})
+	return nil
 }
 
-// InsertTelemetry записывает строку телеметрии в tenant DB.
+// InsertTelemetry ставит строку в батч-буфер тенанта.
+// При накоплении telemetryBatchSize строк батч пишется синхронно (ошибка
+// возвращается вызывающему); неполные батчи дописывает фоновый flusher.
 func (s *IoTPostgresStore) InsertTelemetry(ctx context.Context, namespace, deviceID string, payload json.RawMessage) error {
-	tenantDB, err := s.getTenantDB(ctx, namespace)
+	s.mu.Lock()
-	if err != nil {
+	s.batches[namespace] = append(s.batches[namespace], telemetryInsert{
-		return fmt.Errorf("iotpg: get tenant DB for insert: %w", err)
+		deviceID: deviceID,
+		payload:  append([]byte(nil), payload...),
+	})
+	full := len(s.batches[namespace]) >= telemetryBatchSize
+	var rows []telemetryInsert
+	if full {
+		rows = s.batches[namespace]
+		delete(s.batches, namespace)
 	}
-	_, err = tenantDB.ExecContext(ctx,
+	s.mu.Unlock()
-		`INSERT INTO iot_telemetry (device_id, payload) VALUES ($1, $2)`,
+
-		deviceID, []byte(payload),
+	if full {
-	)
+		return s.flushTenant(namespace, rows)
-	return err
+	}
+	return nil
 }
 
 // QueryTelemetry читает телеметрию из tenant DB (ts DESC).
-// deviceID — фильтр (пустая строка = все устройства). limit — max записей (50..1000).
+// deviceID — фильтр (пустая строка = все устройства). limit — max записей
-// Если tenant DB не существует (данных ещё нет) — возвращает пустой срез без ошибки.
+// (50..1000), offset — смещение для пагинации.
-func (s *IoTPostgresStore) QueryTelemetry(ctx context.Context, namespace, deviceID string, limit int) ([]TelemetryRow, error) {
+// Если tenant DB не существует (данных ещё нет) — пустой срез без ошибки.
+func (s *IoTPostgresStore) QueryTelemetry(ctx context.Context, namespace, deviceID string, limit, offset int) ([]TelemetryRow, error) {
 	if limit <= 0 {
 		limit = 50
 	}
 	if limit > 1000 {
 		limit = 1000
 	}
+	if offset < 0 {
+		offset = 0
+	}
 	tenantDB, err := s.getTenantDB(ctx, namespace)
 	if err != nil {
 		// Если DB не существует — тенант ещё не отправлял данные, это нормально
@@ -197,14 +327,14 @@ func (s *IoTPostgresStore) QueryTelemetry(ctx context.Context, namespace, device
 	if deviceID != "" {
 		rows, err = tenantDB.QueryContext(ctx,
 			`SELECT id, device_id, ts, payload FROM iot_telemetry
- WHERE device_id = $1 ORDER BY ts DESC LIMIT $2`,
+ WHERE device_id = $1 ORDER BY ts DESC LIMIT $2 OFFSET $3`,
-			deviceID, limit,
+			deviceID, limit, offset,
 		)
 	} else {
 		rows, err = tenantDB.QueryContext(ctx,
 			`SELECT id, device_id, ts, payload FROM iot_telemetry
- ORDER BY ts DESC LIMIT $1`,
+ ORDER BY ts DESC LIMIT $1 OFFSET $2`,
-			limit,
+			limit, offset,
 		)
 	}
 	if err != nil {
@@ -301,7 +431,6 @@ FROM iot_telemetry`).Scan(&stats.Total, &stats.Last1h, &stats.Last24h)
 		latestRows, err := tenantDB.QueryContext(ctx,
 			`SELECT id, device_id, ts, payload FROM iot_telemetry ORDER BY ts DESC LIMIT 5`)
 		if err == nil {
-			defer latestRows.Close()
 			for latestRows.Next() {
 				var r TelemetryRow
 				var rawPayload []byte
@@ -310,6 +439,7 @@ FROM iot_telemetry`).Scan(&stats.Total, &stats.Last1h, &stats.Last24h)
 					stats.Latest = append(stats.Latest, r)
 				}
 			}
+			latestRows.Close() // закрываем сразу, не defer в цикле
 		}
 
 		result.Tenants = append(result.Tenants, stats)
@@ -329,8 +459,11 @@ func isDBNotExistErr(err error) bool {
 	return false
 }
 
-// Close закрывает все подключения (admin + tenant кэш).
+// Close останавливает flusher, дописывает остаток и закрывает все подключения.
 func (s *IoTPostgresStore) Close() error {
+	close(s.stopFlush)
+	s.flushWG.Wait()
+	_ = s.flushAll(true)
 	s.tenants.Range(func(_, value any) bool {
 		if db, ok := value.(*sql.DB); ok {
 			db.Close()
@@ -341,7 +474,16 @@ func (s *IoTPostgresStore) Close() error {
 }
 
 // getTenantDB возвращает *sql.DB для tenant DB из кэша или открывает новый.
+// Открытие дедуплицируется per-namespace мьютексом (гонка Load→LoadOrStore
+// из ревью 2026-08-16).
 func (s *IoTPostgresStore) getTenantDB(ctx context.Context, namespace string) (*sql.DB, error) {
+	if cached, ok := s.tenants.Load(namespace); ok {
+		return cached.(*sql.DB), nil
+	}
+	m, _ := s.tenantMu.LoadOrStore(namespace, &sync.Mutex{})
+	mu := m.(*sync.Mutex)
+	mu.Lock()
+	defer mu.Unlock()
 	if cached, ok := s.tenants.Load(namespace); ok {
 		return cached.(*sql.DB), nil
 	}

legacy/2026-08-13-migration-to-managed.md

@@ -0,0 +1,224 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ план миграции (Node.js). ОТМЕНЁН. НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Миграция IoT из Kubernetes → Managed Services (Nubes)
+## Сессия 2026-08-13
+
+---
+
+## 1. Что изучили — текущая архитектура
+
+### Стек
+- **Язык:** Go 1.25
+- **Паттерн:** Kubernetes Operator (controller-runtime)
+- **Модуль:** `gitea.services.ngcloud.ru/Nail/IoT`
+- **Docker Hub:** `naeel/iot-operator:v0.2.6`
+
+### Три бинарника в одном образе
+| Бинарник | Роль |
+|---|---|
+| `cmd/iot-operator` | Controller-manager (CRD IoTDevice) + REST API :9090 |
+| `cmd/mqtt-bridge` | MQTT (EMQX) → shared-SQS (AWS SDK v2) |
+| `cmd/sqs-consumer` | shared-SQS → per-tenant Postgres |
+
+### Поток данных (текущий)
+```
+IoT Device (MQTT CONNECT, username="{ns}_{deviceId}")
+    ↓
+EMQX 5.5.1 (HTTP auth/acl → iot-operator:9090/internal/mqtt/auth)
+    ↓ MQTT PUBLISH "{ns}/telemetry/{deviceId}"
+iot-mqtt-bridge (подписка "+/telemetry/+")
+    ↓ AWS SDK SQS SendMessage
+shared-SQS (namespace shared-sqs, очередь "iot-telemetry")
+    ↓ long polling (WaitTimeSeconds=20)
+iot-sqs-consumer (at-least-once, DeleteMessage после успешной записи)
+    ↓
+Managed PostgreSQL 17 (per-tenant DB: tenant_{namespace})
+    ↓
+REST API (iot-operator:9090) → Пользователь (UI/Terraform)
+```
+
+### Ключевые компоненты k8s
+- **CRD IoTDevice** (`iot.kube5s.ru/v1alpha1`) — регистрация устройств
+- **k8s Secret** `iot-{deviceId}` — хранит MQTT пароль (64 hex, crypto/rand)
+- **OwnerReference** — каскадное удаление Secret при удалении IoTDevice
+- **RBAC** — ClusterRole для чтения/записи IoTDevice + Secrets
+- **Namespace = ID тенанта** — изоляция устройств и данных
+
+### Мультитенантность
+- MQTT topic изоляция: `{ns}/telemetry/{deviceId}` — ACL на уровне EMQX
+- Per-tenant Postgres DB: `tenant_{namespace}` (дефисы → подчёркивания)
+- MQTT username: `{namespace}_{deviceId}` — глобально уникален
+- `sync.Map` кэш `*sql.DB` per tenant — lazy init
+
+### Наблюдения / потенциальные проблемы
+1. **`authTestMode = true`** в `middleware/auth.go` — тестовый режим включён в проде, JWT подпись не проверяется
+2. **`ADMIN_STATS_TOKEN = "iot-admin-2026"`** захардкожен в YAML манифесте вместо Secret
+3. Устаревшие файлы: `deployments/k8s/kafka.yaml`, `iot-kafka-consumer.yaml` (Kafka удалена, манифесты остались)
+4. Bridge clientID `"sless-iot-bridge"` захардкожен и в bridge коде и в ACL логике
+5. `examples/main.tf` и `handler.py` описывают устаревший поток (RabbitMQ/serverless)
+
+---
+
+## 2. Почему хотим уйти из k8s
+
+- Цель: использовать только **managed services** облака Nubes
+- Nubes предоставляет: **Managed Node.js, Flask, Lucee, PostgreSQL**
+- Никаких VPS, никакого k8s — только managed-платформа
+- SQS тоже **наш собственный сервис** (не сторонний облачный), работает сейчас в k8s, тоже надо вынести
+
+---
+
+## 3. Принятые решения
+
+### Node.js — выбранный стек
+| Задача | Node.js |
+|---|---|
+| REST API | Express/Fastify |
+| MQTT-брокер | `aedes` (embedded, over WebSocket) |
+| MQTT-клиент для publish | `mqtt` npm |
+| SQS клиент | `@aws-sdk/client-sqs` |
+| Postgres | `pg` npm |
+
+**Почему не Flask:** сложнее держать persistent MQTT и SQS polling в фоне  
+**Почему не Lucee:** не подходит для long-running background workers  
+**Почему Node.js — монолит:** bridge и consumer нельзя масштабировать независимо (один MQTT-клиент = одна подписка), смысла разделять нет
+
+### EMQX → aedes (embedded в Node.js)
+- Managed Node.js открывает только HTTP/HTTPS порты
+- MQTT over WebSocket = HTTP upgrade → работает на любой managed-платформе
+- Устройства подключаются через `wss://` (уже сейчас так, через ingress emqx-ws-ingress.yaml)
+- **aedes** — полноценный MQTT-брокер на Node.js, встраивается в Express HTTP-сервер
+- Auth/ACL становится обычной функцией внутри того же процесса (быстрее, проще)
+
+### Мультитенантность сохраняется полностью
+- `namespace` — просто строка в таблице `iot_devices` вместо k8s namespace
+- Per-tenant Postgres DB остаётся (чистый SQL, без k8s)
+- MQTT topic изоляция остаётся (`{ns}/telemetry/{deviceId}`)
+- ACL по топику остаётся — просто функция вместо HTTP endpoint
+
+### k8s CRD/Secret → таблица в Postgres
+```sql
+CREATE TABLE iot_devices (
+  namespace     TEXT NOT NULL,
+  name          TEXT NOT NULL,
+  device_id     TEXT NOT NULL,
+  enabled       BOOLEAN NOT NULL DEFAULT true,
+  mqtt_password TEXT NOT NULL,  -- было в k8s Secret
+  metadata      JSONB,
+  phase         TEXT,
+  created_at    TIMESTAMPTZ DEFAULT now(),
+  PRIMARY KEY (namespace, device_id)
+);
+```
+
+---
+
+## 4. Итоговая архитектура на Nubes Managed
+
+```
+IoT Device (wss://iot.example.ru/mqtt)
+      ↓
+Managed Node.js — IoT сервис
+  ├── aedes MQTT-брокер (over WebSocket, порт :3000/mqtt)
+  │     auth/acl → функция → таблица iot_devices в PG
+  │     on publish → SQS SendMessage
+  ├── SQS consumer (long polling, фоновый setInterval/async loop)
+  │     → per-tenant Postgres (tenant_{namespace})
+  └── REST API (Express)
+        GET/POST /v1/namespaces/{ns}/iot/devices
+        GET      /v1/namespaces/{ns}/iot/telemetry
+        POST     /internal/mqtt/auth  (совместимость, опционально)
+        GET      /console  (embedded HTML)
+        GET      /iot-admin/stats
+      ↓
+Managed Node.js — shared-SQS сервис  ← другие сервисы тоже
+      ↓
+Managed PostgreSQL — IoT данные
+```
+
+### Два managed Node.js сервиса
+| Сервис | Назначение |
+|---|---|
+| **shared-SQS** | AWS SQS-совместимая очередь, multi-tenant, HTTP API |
+| **iot-service** | aedes MQTT + REST API + SQS consumer + PG |
+
+---
+
+## 5. Порядок миграции
+
+### ⚠️ Сначала shared-SQS, потом IoT
+
+**Причина:** IoT зависит от SQS. SQS независим — мигрирует первым.
+
+```
+Шаг 1: Вынести shared-SQS из k8s → Managed Node.js на Nubes
+Шаг 2: Переписать IoT сервис на Node.js (aedes + REST + consumer)
+Шаг 3: Деплой IoT на Managed Node.js на Nubes
+Шаг 4: Отключить k8s деплой IoT
+```
+
+---
+
+## 6. Детали для нового чата — shared-SQS миграция
+
+### Что сейчас
+- SQS сервис живёт в `namespace: shared-sqs` в кластере `iot-naeel`
+- Endpoint: `https://qu.kube5s.ru`
+- Multi-tenant: tenant `iot-service` (id: `t-96afe7e9f781f6ca`), очередь `iot-telemetry`
+- IoT использует: `SQS_ENDPOINT=https://qu.kube5s.ru`, `SQS_ACCESS_KEY`, `SQS_SECRET_KEY`
+- Протокол: AWS SQS-совместимый (SendMessage, ReceiveMessage, DeleteMessage, GetQueueUrl, GetQueueAttributes)
+
+### Что нужно от нового SQS сервиса
+- AWS SQS-совместимый HTTP API (те же методы что сейчас)
+- Multi-tenant (разные access key / secret key для разных тенантов)
+- Очереди создаются по имени (`GetQueueUrl` + `CreateQueue`)
+- Long polling: `ReceiveMessage` с `WaitTimeSeconds` до 20
+- Хранение сообщений: in-memory или Postgres/Redis
+
+### Клиенты SQS в IoT коде
+1. **mqtt-bridge** (`cmd/mqtt-bridge/main.go`): `SendMessage` при каждом MQTT сообщении
+2. **sqs-consumer** (`cmd/sqs-consumer/main.go`): `ReceiveMessage` (polling) + `DeleteMessage`
+3. **iot-admin-stats** (`internal/api/handler/iot_admin_stats_handler.go`): `GetQueueAttributes` для мониторинга
+
+### Env vars для IoT → SQS
+```
+SQS_ENDPOINT=https://qu.kube5s.ru   (поменяется на новый managed URL)
+SQS_ACCESS_KEY=...
+SQS_SECRET_KEY=...
+SQS_QUEUE_NAME=iot-telemetry        (default)
+SQS_REGION=us-east-1                (default, не важен для self-hosted)
+```
+
+---
+
+## 7. Что переписывается в IoT (Node.js)
+
+### Соответствие Go → Node.js
+
+| Go файл | Node.js файл |
+|---|---|
+| `cmd/iot-operator/main.go` | `src/index.js` (точка входа) |
+| `internal/api/router.go` | `src/routes.js` |
+| `internal/api/handler/iot_device_handler.go` | `src/handlers/devices.js` |
+| `internal/api/handler/iot_telemetry_handler.go` | `src/handlers/telemetry.js` |
+| `internal/api/handler/iot_admin_stats_handler.go` | `src/handlers/admin.js` |
+| `internal/api/middleware/auth.go` | `src/middleware/auth.js` |
+| `internal/storage/iotpg/iot_telemetry_store.go` | `src/storage/pg.js` |
+| `cmd/mqtt-bridge/main.go` | встроен в `src/mqtt.js` (aedes) |
+| `cmd/sqs-consumer/main.go` | встроен в `src/sqsWorker.js` |
+| `controllers/iotdevice_controller.go` | **не нужен** (заменён CRUD в БД) |
+| `api/v1alpha1/device_types.go` | **не нужен** (таблица iot_devices) |
+
+### npm зависимости
+```json
+{
+  "dependencies": {
+    "express": "^4",
+    "aedes": "^0.51",
+    "websocket-stream": "^5",
+    "@aws-sdk/client-sqs": "^3",
+    "pg": "^8",
+    "uuid": "^9"
+  }
+}
+```

legacy/Dockerfile.old

@@ -0,0 +1,43 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (3 бинарника, образ naeel/iot-operator). НЕ ИСПОЛЬЗОВАТЬ.
+# Новый монолит получит собственный Dockerfile. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-12
+# Изменено: 2026-04-12 (kafka-consumer → sqs-consumer)
+# Dockerfile для IoT managed service.
+# Multi-stage build: 3 бинарника (iot-operator, mqtt-bridge, sqs-consumer).
+# Образ: naeel/iot-operator (Docker Hub).
+
+FROM golang:1.25 AS builder
+WORKDIR /workspace
+
+# Кэширование зависимостей
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Исходный код
+COPY api/ api/
+COPY controllers/ controllers/
+COPY cmd/ cmd/
+COPY internal/ internal/
+
+# iot-operator — controller-manager + REST API
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o iot-operator ./cmd/iot-operator/
+
+# mqtt-bridge — MQTT (EMQX) → shared-SQS
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o mqtt-bridge ./cmd/mqtt-bridge/
+
+# sqs-consumer — shared-SQS → Postgres
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o sqs-consumer ./cmd/sqs-consumer/
+
+# --- Runtime ---
+FROM gcr.io/distroless/static:nonroot
+WORKDIR /
+
+# Все три бинарника в одном образе.
+# Какой запускать — определяется command в k8s Deployment.
+COPY --from=builder /workspace/iot-operator .
+COPY --from=builder /workspace/mqtt-bridge .
+COPY --from=builder /workspace/sqs-consumer .
+
+USER 65532:65532
+ENTRYPOINT ["/iot-operator"]

legacy/Makefile.old

@@ -0,0 +1,34 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). Цели deploy/install-crd не использовать.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-12
+# Makefile для IoT managed service.
+
+IMG ?= naeel/iot-operator:latest
+
+.PHONY: build build-all docker-build docker-push test tidy
+
+# Собрать все бинарники
+build-all: build-operator build-bridge build-consumer
+
+build-operator:
+CGO_ENABLED=0 go build -o bin/iot-operator ./cmd/iot-operator/
+
+build-bridge:
+CGO_ENABLED=0 go build -o bin/mqtt-bridge ./cmd/mqtt-bridge/
+
+build-consumer:
+	CGO_ENABLED=0 go build -o bin/sqs-consumer ./cmd/sqs-consumer/
+test:
+go test ./...
+
+tidy:
+go mod tidy
+
+# Применить CRD в кластер
+install-crd:
+kubectl apply -f config/crd/bases/
+
+# Деплой всех компонентов
+deploy:
+kubectl apply -f deployments/k8s/

legacy/config/crd/bases/iot.kube5s.ru_iotdevices.yaml

@@ -1,3 +1,6 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (CRD/k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
 ---
 apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition

legacy/deployments/k8s/emqx-ws-ingress.yaml

@@ -0,0 +1,68 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-12
+# MQTT over WebSocket через Ingress с TLS termination.
+# Причина: порт 1883 заблокирован NSX-T Edge firewall на уровне облака.
+# Решение: EMQX WebSocket listener (8083) проксируется через nginx-ingress с TLS.
+#
+# IoT устройство подключается: wss://iot.kube5s.ru/mqtt
+# IoT Консоль (UI): https://iot.kube5s.ru/console
+#
+# DNS A-запись: iot.kube5s.ru → 185.247.187.147
+# TLS: терминируется внешним слоем платформы (185.247.187.147).
+#      cert-manager НЕ используется — HTTP-01 challenge недоступен т.к. платформа
+#      глобально редиректит HTTP→HTTPS до nginx.
+#
+# Применение: kubectl apply -f deployments/k8s/emqx-ws-ingress.yaml
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: emqx-ws
+  namespace: sless
+  # Отдельный Service — WebSocket порт для Ingress
+spec:
+  selector:
+    app: emqx
+  ports:
+    - name: mqtt-ws
+      port: 8083
+      targetPort: 8083
+      protocol: TCP
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: emqx-mqtt-websocket
+  namespace: sless
+  annotations:
+    kubernetes.io/ingress.class: nginx
+    nginx.ingress.kubernetes.io/ssl-redirect: "false"
+    # WebSocket: nginx-ingress добавляет Upgrade/Connection при proxy-http-version=1.1
+    nginx.ingress.kubernetes.io/proxy-http-version: "1.1"
+    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
+    nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
+spec:
+  ingressClassName: nginx
+  rules:
+    - host: iot.kube5s.ru
+      http:
+        paths:
+          # MQTT over WebSocket — wss://iot.kube5s.ru/mqtt
+          - path: /mqtt
+            pathType: Exact
+            backend:
+              service:
+                name: emqx-ws
+                port:
+                  number: 8083
+          # IoT Консоль (UI) — https://iot.kube5s.ru/console
+          - path: /console
+            pathType: Exact
+            backend:
+              service:
+                name: iot-operator
+                port:
+                  number: 9090

legacy/deployments/k8s/emqx.yaml

@@ -0,0 +1,196 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-12
+# EMQX MQTT-брокер для IoT-сервиса (namespace: sless).
+#
+# Архитектура:
+#   IoT Device → MQTT CONNECT → EMQX (HTTP auth → iot-operator:9090/internal/mqtt/auth)
+#   EMQX → MQTT PUBLISH → iot-mqtt-bridge (paho subscriber) → shared-SQS queue iot-telemetry
+#   SQS → iot-sqs-consumer → Postgres
+#
+# EMQX 5.x конфиг через emqx.conf (HOCON формат), монтируется как ConfigMap volume.
+#
+# Порты:
+#   1883 — MQTT (plaintext)
+#   8083 — MQTT over WebSocket
+#   18083 — EMQX Dashboard (admin/public по умолчанию — менять в prod!)
+#
+# Применение: kubectl apply -f deployments/k8s/emqx.yaml
+
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: emqx-config
+  namespace: sless
+data:
+  # emqx.conf — HOCON конфиг для EMQX 5.5.x
+  # Раздел authentication: HTTP Backend для проверки MQTT credentials IoT-устройств.
+  # iot-operator ищет Secret iot-{deviceId} и сравнивает пароль.
+  emqx.conf: |
+    ## EMQX 5.x configuration (HOCON format)
+    ## Создано: 2026-04-12
+
+    ## node — без них EMQX 5.x падает при старте
+    ## node.cookie — секрет кластерного Erlang-соединения, для single-node любая строка
+    ## node.data_dir — директория данных (mnesia, конфиги)
+    node {
+      name = "emqx@127.0.0.1"
+      cookie = "iot-emqx-cookie-mvp"
+      data_dir = "/opt/emqx/data"
+    }
+
+    ## HTTP Auth Backend для IoT-устройств
+    ## EMQX посылает POST с {username, password, clientid} → iot-operator отвечает {"result":"allow"|"deny"}
+    authentication = [
+      {
+        mechanism = password_based
+        backend = http
+        enable = true
+        method = post
+        url = "http://iot-operator.sless.svc:9090/internal/mqtt/auth"
+        body {
+          username = "${username}"
+          password = "${password}"
+          clientid = "${clientid}"
+        }
+        headers {
+          "content-type" = "application/json"
+        }
+        connect_timeout = 5s
+        request_timeout = 5s
+        pool_size = 8
+      }
+    ]
+
+    ## Authorization (ACL) — HTTP backend для изоляции топиков по устройству.
+    ## no_match = deny: если HTTP backend недоступен или не ответил — запрещаем.
+    ## Endpoint /internal/mqtt/acl возвращает allow только для топиков {ns}/{deviceId}/#
+    authorization {
+      no_match = deny
+      deny_action = disconnect
+      cache {
+        enable = true
+        max_size = 32
+        ttl = 1m
+      }
+      sources = [
+        {
+          type = http
+          enable = true
+          method = post
+          url = "http://iot-operator.sless.svc:9090/internal/mqtt/acl"
+          body {
+            username = "${username}"
+            clientid = "${clientid}"
+            action = "${action}"
+            topic = "${topic}"
+          }
+          headers {
+            "content-type" = "application/json"
+          }
+          connect_timeout = 5s
+          request_timeout = 5s
+          pool_size = 8
+        }
+      ]
+    }
+
+    ## MQTT настройки
+    mqtt {
+      max_packet_size = 1MB
+      max_topic_levels = 10
+      retain_available = false
+    }
+
+    ## Listeners — plaintext MQTT + WebSocket
+    listeners.tcp.default {
+      bind = "0.0.0.0:1883"
+      max_connections = 1024
+    }
+
+    listeners.ws.default {
+      bind = "0.0.0.0:8083"
+      max_connections = 512
+    }
+
+    ## Dashboard
+    dashboard {
+      listeners.http {
+        bind = 18083
+      }
+    }
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: emqx
+  namespace: sless
+  labels:
+    app: emqx
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: emqx
+  template:
+    metadata:
+      labels:
+        app: emqx
+    spec:
+      containers:
+        - name: emqx
+          image: emqx/emqx:5.5.1
+          ports:
+            - name: mqtt
+              containerPort: 1883
+            - name: ws
+              containerPort: 8083
+            - name: dashboard
+              containerPort: 18083
+          volumeMounts:
+            - name: emqx-conf
+              mountPath: /opt/emqx/etc/emqx.conf
+              subPath: emqx.conf
+          resources:
+            requests:
+              memory: "256Mi"
+              cpu: "100m"
+            limits:
+              memory: "512Mi"
+              cpu: "500m"
+          readinessProbe:
+            tcpSocket:
+              port: 1883
+            initialDelaySeconds: 20
+            periodSeconds: 10
+            timeoutSeconds: 5
+          livenessProbe:
+            tcpSocket:
+              port: 1883
+            initialDelaySeconds: 40
+            periodSeconds: 20
+      volumes:
+        - name: emqx-conf
+          configMap:
+            name: emqx-config
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: emqx
+  namespace: sless
+spec:
+  selector:
+    app: emqx
+  ports:
+    - name: mqtt
+      port: 1883
+      targetPort: 1883
+    - name: ws
+      port: 8083
+      targetPort: 8083
+    - name: dashboard
+      port: 18083
+      targetPort: 18083

legacy/deployments/k8s/iot-kafka-consumer.yaml

@@ -1,3 +1,6 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой, Kafka). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
 # Создано: 2026-04-06
 # Deployment iot-kafka-consumer — читает IoT телеметрию из Kafka → пишет в IoT Postgres.
 #

legacy/deployments/k8s/iot-mqtt-bridge.yaml

@@ -0,0 +1,66 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-04
+# Изменено: 2026-04-12 (замена Kafka → shared-SQS)
+# Deployment iot-mqtt-bridge — MQTT→SQS мост для IoT.
+#
+# Получает MQTT сообщения от EMQX (подписка на "+/telemetry/+")
+# и отправляет в shared-SQS очередь "iot-telemetry" через AWS SDK.
+#
+# Credentials для MQTT подключения берутся из Secret iot-bridge-credentials.
+# Credentials для SQS берутся из Secret iot-sqs-credentials.
+#
+# Создание SQS Secret (один раз):
+#   kubectl create secret generic iot-sqs-credentials -n sless \
+#     --from-literal=SQS_ENDPOINT="https://qu.kube5s.ru" \
+#     --from-literal=SQS_ACCESS_KEY="<access_key>" \
+#     --from-literal=SQS_SECRET_KEY="<secret_key>"
+#
+# Применение: kubectl apply -f deployments/k8s/iot-mqtt-bridge.yaml
+
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: iot-mqtt-bridge
+  namespace: sless
+  labels:
+    app: iot-mqtt-bridge
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: iot-mqtt-bridge
+  template:
+    metadata:
+      labels:
+        app: iot-mqtt-bridge
+    spec:
+      containers:
+        - name: mqtt-bridge
+          # Тот же образ что и оператор — оба бинаря в одном слое (manager + iot-mqtt-bridge).
+          # При смене версии оператора — менять тег и здесь.
+          image: naeel/iot-operator:v0.2.6
+          imagePullPolicy: Always
+          command: ["/mqtt-bridge"]
+          env:
+            - name: MQTT_BROKER_URL
+              value: "tcp://emqx.sless.svc:1883"
+            - name: SQS_QUEUE_NAME
+              value: "iot-telemetry"
+            - name: SQS_REGION
+              value: "us-east-1"
+          envFrom:
+            - secretRef:
+                name: iot-bridge-credentials
+            # SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY
+            - secretRef:
+                name: iot-sqs-credentials
+          resources:
+            requests:
+              memory: "32Mi"
+              cpu: "25m"
+            limits:
+              memory: "64Mi"
+              cpu: "100m"

legacy/deployments/k8s/iot-operator.yaml

@@ -0,0 +1,155 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-12
+# Deployment iot-operator — controller-manager (IoTDevice CRD) + REST API на :9090.
+#
+# Компоненты:
+#   - ServiceAccount + ClusterRole + ClusterRoleBinding (RBAC для CRD controller)
+#   - Deployment: naeel/iot-operator:v0.2.6
+#   - Service: ClusterIP :9090 (REST API, MQTT auth/acl, admin UI)
+#
+# iot-operator обслуживает:
+#   - IoTDevice CRD reconcilation (controller-runtime)
+#   - REST API: устройства, телеметрия, MQTT auth/acl
+#   - Admin UI: /iot-admin
+#   - Console UI: /console
+#
+# Секреты:
+#   iot-postgres-secret — IOT_PG_DSN для managed Postgres
+#   iot-sqs-credentials — SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY
+#
+# Применение: kubectl apply -f deployments/k8s/iot-operator.yaml
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: iot-operator
+  namespace: sless
+---
+# ClusterRole — права на IoTDevice CRD + Secrets (для MQTT auth)
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: iot-operator-role
+rules:
+  # IoTDevice CRD
+  - apiGroups: ["iot.kube5s.ru"]
+    resources: ["iotdevices", "iotdevices/status", "iotdevices/finalizers"]
+    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+  # Secrets — для MQTT auth (чтение device credentials)
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+  # Events — controller-runtime записывает events
+  - apiGroups: [""]
+    resources: ["events"]
+    verbs: ["create", "patch"]
+  # Namespaces — для per-tenant DB provisioning
+  - apiGroups: [""]
+    resources: ["namespaces"]
+    verbs: ["get", "list", "watch"]
+  # Leases — leader election (controller-runtime)
+  - apiGroups: ["coordination.k8s.io"]
+    resources: ["leases"]
+    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: iot-operator-rolebinding
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: iot-operator-role
+subjects:
+  - kind: ServiceAccount
+    name: iot-operator
+    namespace: sless
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: iot-operator
+  namespace: sless
+  labels:
+    app: iot-operator
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: iot-operator
+  template:
+    metadata:
+      labels:
+        app: iot-operator
+    spec:
+      serviceAccountName: iot-operator
+      containers:
+        - name: operator
+          image: naeel/iot-operator:v0.2.6
+          imagePullPolicy: Always
+          ports:
+            - name: api
+              containerPort: 9090
+            - name: metrics
+              containerPort: 8080
+            - name: health
+              containerPort: 8081
+          envFrom:
+            # IOT_PG_DSN — managed Postgres
+            - secretRef:
+                name: iot-postgres-secret
+            # SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY — для admin stats
+            - secretRef:
+                name: iot-sqs-credentials
+          env:
+            - name: API_PORT
+              value: "9090"
+            # ADMIN_STATS_TOKEN — токен доступа к /iot-admin/stats
+            - name: ADMIN_STATS_TOKEN
+              value: "iot-admin-2026"
+            # Bridge MQTT credentials — для авторизации внутреннего mqtt-bridge
+            - name: MQTT_BRIDGE_USERNAME
+              valueFrom:
+                secretKeyRef:
+                  name: iot-bridge-credentials
+                  key: MQTT_USERNAME
+            - name: MQTT_BRIDGE_PASSWORD
+              valueFrom:
+                secretKeyRef:
+                  name: iot-bridge-credentials
+                  key: MQTT_PASSWORD
+          readinessProbe:
+            httpGet:
+              path: /healthz
+              port: 8081
+            initialDelaySeconds: 5
+            periodSeconds: 10
+          livenessProbe:
+            httpGet:
+              path: /healthz
+              port: 8081
+            initialDelaySeconds: 15
+            periodSeconds: 20
+          resources:
+            requests:
+              memory: "64Mi"
+              cpu: "50m"
+            limits:
+              memory: "256Mi"
+              cpu: "500m"
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: iot-operator
+  namespace: sless
+spec:
+  selector:
+    app: iot-operator
+  ports:
+    - name: api
+      port: 9090
+      targetPort: 9090

legacy/deployments/k8s/iot-postgres.yaml

@@ -0,0 +1,29 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-05
+# Изменено: 2026-04-12 (заменён self-hosted на managed Postgres через оператор)
+#
+# Managed PostgreSQL 17 — тот же инстанс что использует shared-SQS.
+# Namespace: dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5 (managed оператором)
+# Host: postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local
+#
+# IoT оператор использует суперюзер для:
+#   - CREATE USER tenant_{ns} + CREATE DATABASE tenant_{ns}
+#   - CREATE TABLE iot_telemetry в tenant DB
+# Клиенты НЕ имеют прямого доступа — только через REST API платформы.
+#
+# Deployment и Service удалены — Postgres managed, только Secret с DSN.
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: iot-postgres-secret
+  namespace: sless
+stringData:
+  # Суперпользователь managed Postgres
+  POSTGRES_USER: "super"
+  POSTGRES_PASSWORD: "BQUF5ruECa1ZFlq4wYt3gPJUEmtBMkA9QNK4MM5Sd8al4ArMDlmT16DIKHYBPyif"
+  POSTGRES_DB: "sqsdb"
+  # DSN для iot-operator и sqs-consumer (superuser к managed DB)
+  IOT_PG_DSN: "postgresql://super:BQUF5ruECa1ZFlq4wYt3gPJUEmtBMkA9QNK4MM5Sd8al4ArMDlmT16DIKHYBPyif@postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local:5432/sqsdb?sslmode=disable"

legacy/deployments/k8s/iot-sqs-consumer.yaml

@@ -0,0 +1,63 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Создано: 2026-04-12
+# Deployment iot-sqs-consumer — читает IoT телеметрию из shared-SQS → пишет в IoT Postgres.
+#
+# Long polling (WaitTimeSeconds=20) — минимизирует пустые запросы.
+# Сообщение удаляется из SQS только после успешной записи в Postgres (at-least-once).
+#
+# Credentials для SQS берутся из Secret iot-sqs-credentials.
+# IOT_PG_DSN берётся из Secret iot-postgres-secret.
+#
+# Создание SQS Secret (один раз, если ещё не создан):
+#   kubectl create secret generic iot-sqs-credentials -n sless \
+#     --from-literal=SQS_ENDPOINT="https://qu.kube5s.ru" \
+#     --from-literal=SQS_ACCESS_KEY="<access_key>" \
+#     --from-literal=SQS_SECRET_KEY="<secret_key>"
+#
+# Применение: kubectl apply -f deployments/k8s/iot-sqs-consumer.yaml
+
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: iot-sqs-consumer
+  namespace: sless
+  labels:
+    app: iot-sqs-consumer
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: iot-sqs-consumer
+  template:
+    metadata:
+      labels:
+        app: iot-sqs-consumer
+    spec:
+      containers:
+        - name: sqs-consumer
+          # Тот же образ что и оператор — все IoT бинари в одном образе.
+          image: naeel/iot-operator:v0.2.6
+          imagePullPolicy: Always
+          command: ["/sqs-consumer"]
+          env:
+            - name: SQS_QUEUE_NAME
+              value: "iot-telemetry"
+            - name: SQS_REGION
+              value: "us-east-1"
+          envFrom:
+            # SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY
+            - secretRef:
+                name: iot-sqs-credentials
+            # IOT_PG_DSN — master DSN для IoT Postgres (per-tenant DB)
+            - secretRef:
+                name: iot-postgres-secret
+          resources:
+            requests:
+              memory: "32Mi"
+              cpu: "25m"
+            limits:
+              memory: "64Mi"
+              cpu: "100m"

legacy/deployments/k8s/kafka.yaml

@@ -1,3 +1,6 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой, Kafka). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ.
+# Актуальное: HISTORY/2026-08-16-session-log.md
+
 # Изменено: 2026-04-06 (добавлен postStart hook для предсоздания топика iot.telemetry)
 # kafka.yaml — минимальный деплой Apache Kafka в KRaft mode (без Zookeeper).
 # Образ: apache/kafka (официальный, бесплатный).

legacy/doc/api/endpoints-v0.2.3.md

@@ -0,0 +1,412 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# IoT REST API — Полная документация (v0.2.3)
+
+> Дата: 2026-04-12
+> Базовый URL: https://iot.kube5s.ru (через Ingress) или http://iot-operator.sless.svc:9090 (из кластера)
+> Аутентификация: Bearer JWT в заголовке Authorization (authTestMode=true: любой непустой токен)
+
+---
+
+## Содержание
+
+1. [IoT Devices CRUD](#iot-devices-crud)
+2. [IoT Telemetry](#iot-telemetry)
+3. [MQTT Auth (internal)](#mqtt-auth-internal)
+4. [MQTT ACL (internal)](#mqtt-acl-internal)
+5. [Admin Stats](#admin-stats)
+6. [UI Pages](#ui-pages)
+7. [Коды ошибок](#коды-ошибок)
+
+---
+
+## IoT Devices CRUD
+
+### POST /v1/namespaces/{namespace}/iot/devices — Создание устройства
+
+Создаёт IoTDevice CRD. Контроллер асинхронно генерирует MQTT credentials (Secret).
+
+**Headers:**
+```
+Authorization: Bearer <token>
+Content-Type: application/json
+```
+
+**Request body:**
+```json
+{
+  "name": "sensor-01",
+  "device_id": "sensor-01",
+  "enabled": true,
+  "metadata": {
+    "model": "DHT22",
+    "location": "room-1"
+  }
+}
+```
+
+| Поле | Тип | Обязательное | Описание |
+|------|-----|-------------|----------|
+| name | string | да | Имя k8s объекта IoTDevice (уникальное в namespace) |
+| device_id | string | да | ID устройства, pattern: ^[a-z0-9][a-z0-9-]*[a-z0-9]$ |
+| enabled | bool | нет | default: true |
+| metadata | map[string]string | нет | Произвольные метаданные |
+
+**Response 201 Created:**
+```json
+{
+  "name": "sensor-01",
+  "namespace": "tenant-abc",
+  "device_id": "sensor-01",
+  "enabled": true,
+  "phase": "",
+  "metadata": {"model": "DHT22", "location": "room-1"},
+  "created_at": "2026-04-12 14:30:00 UTC"
+}
+```
+
+**Response 409 Conflict:** `{"error": "iot device already exists"}`
+
+---
+
+### GET /v1/namespaces/{namespace}/iot/devices — Список устройств
+
+Возвращает все IoTDevice в namespace. **Пароли НЕ включены** (security by design).
+
+**Headers:**
+```
+Authorization: Bearer <token>
+```
+
+**Response 200 OK:**
+```json
+[
+  {
+    "name": "sensor-01",
+    "namespace": "tenant-abc",
+    "device_id": "sensor-01",
+    "enabled": true,
+    "phase": "Active",
+    "mqtt_username": "tenant-abc_sensor-01",
+    "secret_name": "iot-sensor-01",
+    "topic_prefix": "tenant-abc/",
+    "metadata": {"model": "DHT22"},
+    "created_at": "2026-04-12 14:30:00 UTC"
+  }
+]
+```
+
+---
+
+### GET /v1/namespaces/{namespace}/iot/devices/{name} — Получение устройства
+
+Возвращает устройство **включая mqtt_password** из Secret.
+Используется для конфигурации физического устройства.
+
+**Headers:**
+```
+Authorization: Bearer <token>
+```
+
+**Response 200 OK:**
+```json
+{
+  "name": "sensor-01",
+  "namespace": "tenant-abc",
+  "device_id": "sensor-01",
+  "enabled": true,
+  "phase": "Active",
+  "mqtt_username": "tenant-abc_sensor-01",
+  "mqtt_password": "a1b2c3d4...hex64chars",
+  "secret_name": "iot-sensor-01",
+  "topic_prefix": "tenant-abc/",
+  "last_connected": "2026-04-12T14:35:00Z",
+  "metadata": {"model": "DHT22"},
+  "created_at": "2026-04-12 14:30:00 UTC"
+}
+```
+
+**Response 404:** `{"error": "iot device not found"}`
+
+> Примечание: mqtt_password будет пустым если Secret ещё не создан (phase=Pending).
+
+---
+
+### PATCH /v1/namespaces/{namespace}/iot/devices/{name} — Обновление устройства
+
+Включает/отключает устройство.
+
+**Headers:**
+```
+Authorization: Bearer <token>
+Content-Type: application/json
+```
+
+**Request body:**
+```json
+{
+  "enabled": false
+}
+```
+
+| Поле | Тип | Обязательное | Описание |
+|------|-----|-------------|----------|
+| enabled | bool | да | true=Active, false=Disabled |
+
+**Response 200 OK:** полный объект устройства (без пароля).
+
+**Response 404:** `{"error": "iot device not found"}`
+
+---
+
+### DELETE /v1/namespaces/{namespace}/iot/devices/{name} — Удаление устройства
+
+Удаляет IoTDevice CRD. Контроллер через finalizer удаляет Secret каскадно.
+
+**Headers:**
+```
+Authorization: Bearer <token>
+```
+
+**Response 204 No Content** (пустое тело)
+
+**Response 404:** `{"error": "iot device not found"}`
+
+---
+
+## IoT Telemetry
+
+### GET /v1/namespaces/{namespace}/iot/telemetry — Чтение телеметрии
+
+Возвращает записи телеметрии из per-tenant Postgres.
+
+**Headers:**
+```
+Authorization: Bearer <token>
+```
+
+**Query parameters:**
+
+| Параметр | Тип | Default | Описание |
+|----------|-----|---------|----------|
+| device | string | (все) | Фильтр по device_id |
+| limit | int | 50 | Макс. кол-во записей (max 1000) |
+
+**Response 200 OK:**
+```json
+{
+  "items": [
+    {
+      "id": 1,
+      "device_id": "sensor-01",
+      "payload": {"temperature": 22.5, "humidity": 65},
+      "received_at": "2026-04-12T14:35:00Z",
+      "created_at": "2026-04-12T14:35:01Z"
+    }
+  ],
+  "count": 1
+}
+```
+
+**Response 503:** `{"error": "IoT telemetry storage not configured"}` (IOT_PG_DSN не задан)
+
+---
+
+## MQTT Auth (internal)
+
+### POST /internal/mqtt/auth — Аутентификация MQTT клиента
+
+Вызывается EMQX при каждом MQTT CONNECT. **Без JWT.** Доступен только из кластера.
+
+**Request body (от EMQX):**
+```json
+{
+  "username": "tenant-abc_sensor-01",
+  "password": "a1b2c3d4...hex64chars",
+  "clientid": "mqtt-client-123",
+  "peerhost": "10.0.1.5"
+}
+```
+
+**Логика:**
+1. Если username == BridgeUsername → проверить BridgePassword (constant-time) → allow/deny
+2. Парсить username по первому "_" → namespace + deviceId
+3. Найти Secret `iot-{deviceId}` в namespace
+4. `crypto/subtle.ConstantTimeCompare(password, secret["mqtt-password"])`
+5. Проверить IoTDevice существует и enabled=true
+6. Обновить status.lastConnected (best-effort)
+7. Вернуть ACL правила для клиента
+
+**Response 200 (allow с ACL):**
+```json
+{
+  "result": "allow",
+  "acl": [
+    {"permission": "allow", "action": "publish", "topic": "tenant-abc/telemetry/sensor-01"},
+    {"permission": "allow", "action": "subscribe", "topic": "tenant-abc/telemetry/sensor-01"},
+    {"permission": "deny", "action": "all", "topic": "#"}
+  ]
+}
+```
+
+**Response 200 (bridge allow):**
+```json
+{
+  "result": "allow"
+}
+```
+
+**Response 200 (deny):**
+```json
+{
+  "result": "deny"
+}
+```
+
+> Всегда HTTP 200. EMQX игнорирует non-200 ответы.
+
+---
+
+## MQTT ACL (internal)
+
+### POST /internal/mqtt/acl — Авторизация pub/sub
+
+Вызывается EMQX для каждого publish/subscribe. **Без JWT.**
+
+**Request body:**
+```json
+{
+  "username": "tenant-abc_sensor-01",
+  "clientid": "mqtt-client-123",
+  "action": "publish",
+  "topic": "tenant-abc/telemetry/sensor-01"
+}
+```
+
+**Логика:**
+- Bridge (clientid=sless-iot-bridge): только subscribe → allow. Publish → deny.
+- Device: action на topic `{ns}/telemetry/{deviceId}` → allow. Всё остальное → deny.
+
+**Response 200:** `{"result": "allow"}` или `{"result": "deny"}`
+
+---
+
+## Admin Stats
+
+### GET /iot-admin/stats — Статистика администратора
+
+Защищён токеном ADMIN_STATS_TOKEN (env). Не проходит через JWT middleware.
+
+**Headers:**
+```
+Authorization: Bearer <ADMIN_STATS_TOKEN>
+```
+
+**Response 200 OK:**
+```json
+{
+  "collected_at": "2026-04-12T14:40:00Z",
+  "postgres": {
+    "reachable": true,
+    "tenants": [
+      {
+        "namespace": "tenant-abc",
+        "total_count": 150,
+        "last_1h_count": 42,
+        "last_24h_count": 130,
+        "latest_rows": [...]
+      }
+    ]
+  },
+  "sqs": {
+    "approximate_messages": 5,
+    "approximate_messages_not_visible": 2
+  },
+  "pods": {
+    "iot-mqtt-bridge": {
+      "name": "iot-mqtt-bridge-xxx",
+      "phase": "Running",
+      "ready": true,
+      "restarts": 0,
+      "age": "3h"
+    },
+    "iot-sqs-consumer": {
+      "name": "iot-sqs-consumer-yyy",
+      "phase": "Running",
+      "ready": true,
+      "restarts": 0,
+      "age": "3h"
+    }
+  }
+}
+```
+
+**Response 401:** `{"error": "unauthorized"}`
+**Response 503:** `{"error": "admin stats not configured: ADMIN_STATS_TOKEN not set"}`
+
+---
+
+## UI Pages
+
+### GET /console — IoT Консоль
+
+HTML-страница (go:embed) для управления устройствами и просмотра телеметрии.
+Включает MQTT WebSocket клиент для реального времени.
+
+### GET /iot-admin — IoT Admin Panel
+
+HTML-страница (go:embed) администратора с графиками и мониторингом.
+
+---
+
+## Коды ошибок
+
+| Код | Значение | Когда |
+|-----|---------|-------|
+| 200 | OK | Успешные GET, PATCH, MQTT auth/acl |
+| 201 | Created | Успешный POST (создание устройства) |
+| 204 | No Content | Успешный DELETE |
+| 400 | Bad Request | Невалидный JSON, отсутствуют обязательные поля |
+| 401 | Unauthorized | Невалидный/отсутствующий Bearer token |
+| 404 | Not Found | Устройство не найдено |
+| 409 | Conflict | Устройство уже существует |
+| 500 | Internal Server Error | Ошибка k8s API или БД |
+| 503 | Service Unavailable | IoTPG не сконфигурирован или AdminToken не задан |
+
+---
+
+## Curl примеры
+
+```bash
+# Создать устройство
+curl -X POST https://iot.kube5s.ru/v1/namespaces/test-ns/iot/devices \
+  -H "Authorization: Bearer test-token" \
+  -H "Content-Type: application/json" \
+  -d '{"name":"sensor-01","device_id":"sensor-01","enabled":true}'
+
+# Список устройств
+curl https://iot.kube5s.ru/v1/namespaces/test-ns/iot/devices \
+  -H "Authorization: Bearer test-token"
+
+# Получить устройство с паролем
+curl https://iot.kube5s.ru/v1/namespaces/test-ns/iot/devices/sensor-01 \
+  -H "Authorization: Bearer test-token"
+
+# Включить/отключить
+curl -X PATCH https://iot.kube5s.ru/v1/namespaces/test-ns/iot/devices/sensor-01 \
+  -H "Authorization: Bearer test-token" \
+  -H "Content-Type: application/json" \
+  -d '{"enabled":false}'
+
+# Удалить
+curl -X DELETE https://iot.kube5s.ru/v1/namespaces/test-ns/iot/devices/sensor-01 \
+  -H "Authorization: Bearer test-token"
+
+# Телеметрия (последние 100)
+curl "https://iot.kube5s.ru/v1/namespaces/test-ns/iot/telemetry?limit=100" \
+  -H "Authorization: Bearer test-token"
+
+# Телеметрия по устройству
+curl "https://iot.kube5s.ru/v1/namespaces/test-ns/iot/telemetry?device=sensor-01&limit=50" \
+  -H "Authorization: Bearer test-token"
+```

legacy/doc/api/endpoints.md

@@ -1,3 +1,5 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
 # IoT API Endpoints
 
 ## Публичные (без auth)
@@ -30,3 +32,25 @@
 | Метод | Путь | Описание |
 |-------|------|----------|
 | GET | `/iot-admin/stats` | JSON статистика (PG, Kafka lag, pods) |
+
+---
+
+## Обновление 2026-04-12: admin stats → SQS
+
+> Kafka lag заменён на SQS queue stats. Endpoint тот же, формат ответа изменён.
+
+### `/iot-admin/stats` — актуальный формат ответа
+
+```json
+{
+  "sqs": {
+    "queue_url": "http://us-east-1.goaws.com:4100/t-96afe7e9f781f6ca/iot-telemetry",
+    "approximate_messages": "0",
+    "approximate_messages_not_visible": "0"
+  },
+  "sqs_consumer_pods": [...],
+  "pg_tenants": [...]
+}
+```
+
+Вместо `kafka_lag` теперь `sqs.approximate_messages` — количество сообщений в очереди, ожидающих обработки.

legacy/doc/architecture/current-v0.2.3.md

@@ -0,0 +1,258 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# IoT Managed Service — Актуальная архитектура (v0.2.3)
+
+> Дата: 2026-04-12
+> Образ: naeel/iot-operator:v0.2.3
+> Кластер: iot-naeel, namespace: sless
+
+---
+
+## Путь данных (data flow)
+
+```
+IoT Device (MQTT CONNECT)
+    | username="{ns}_{deviceId}", password=hex(64)
+    v
+EMQX 5.5.1 (Pod emqx, namespace sless)
+    | 1. POST /internal/mqtt/auth -> iot-operator:9090
+    |    - Bridge auth: username=iot-bridge-internal -> allow
+    |    - Device auth: username={ns}_{deviceId} -> Secret -> compare
+    | 2. POST /internal/mqtt/acl -> iot-operator:9090
+    |    - Device: pub/sub только {ns}/telemetry/{deviceId}
+    |    - Bridge: sub на +/telemetry/+ (wildcard)
+    v
+    | MQTT PUBLISH -> topic: "{ns}/telemetry/{deviceId}"
+    v
+iot-mqtt-bridge (Pod, namespace sless)
+    | paho.mqtt.golang, подписка на "+/telemetry/+"
+    | Парсит topic -> namespace (segment 0), deviceId (segment 2)
+    | AWS SDK SQS SendMessage -> shared-SQS
+    v
+shared-SQS (namespace shared-sqs)
+    | Endpoint: https://qu.kube5s.ru
+    | Tenant: iot-service (ID: t-96afe7e9f781f6ca)
+    | Queue: iot-telemetry
+    v
+iot-sqs-consumer (Pod, namespace sless)
+    | ReceiveMessage (WaitTimeSeconds=20, long polling)
+    | Парсит envelope -> namespace, device_id, payload
+    | EnsureTenantDB(namespace) -> CREATE DATABASE tenant_{ns}
+    | INSERT INTO iot_telemetry
+    | DeleteMessage (at-least-once)
+    v
+Managed PostgreSQL 17
+    | Host: postgresqlk8s-master.dc5db45d-....svc.cluster.local
+    | Per-tenant: DATABASE tenant_{namespace}
+    | Таблица: iot_telemetry (id, device_id, payload JSONB, received_at, created_at)
+    v
+REST API (iot-operator:9090)
+    | GET /v1/namespaces/{ns}/iot/telemetry?device=X&limit=N
+    v
+Пользователь
+    | IoT Console: https://iot.kube5s.ru/console
+    | WebSocket MQTT: wss://iot.kube5s.ru/mqtt
+    | Terraform: sless_iot_device resource
+```
+
+---
+
+## Компоненты
+
+### iot-operator (cmd/iot-operator)
+
+Единый бинарник: controller-manager + REST API сервер.
+
+| Функция | Описание |
+|---------|----------|
+| IoTDevice Controller | Reconcile: создание Secret с MQTT credentials, OwnerReference |
+| REST API :9090 | CRUD устройств, телеметрия, MQTT auth/acl, admin stats, UI |
+| Health :8081 | /healthz, /readyz для k8s probes |
+
+### iot-mqtt-bridge (cmd/mqtt-bridge)
+
+MQTT subscriber -> SQS producer. Stateless.
+
+| Параметр | Значение |
+|----------|----------|
+| MQTT broker | tcp://emqx.sless.svc:1883 |
+| MQTT username | iot-bridge-internal (Secret iot-bridge-credentials) |
+| MQTT subscription | +/telemetry/+ |
+| SQS endpoint | https://qu.kube5s.ru |
+| SQS queue | iot-telemetry |
+
+Bridge auth (v0.2.3): operator проверяет BridgeUsername/BridgePassword ДО парсинга namespace_deviceId.
+
+### iot-sqs-consumer (cmd/sqs-consumer)
+
+SQS consumer -> Postgres writer. Stateless.
+
+| Параметр | Значение |
+|----------|----------|
+| SQS endpoint | https://qu.kube5s.ru |
+| SQS queue | iot-telemetry |
+| Long polling | WaitTimeSeconds=20 |
+| Postgres | IOT_PG_DSN из Secret |
+| Семантика | at-least-once (DeleteMessage после INSERT) |
+
+### EMQX 5.5.1
+
+MQTT-брокер с HTTP auth backend.
+
+| Параметр | Значение |
+|----------|----------|
+| Образ | emqx/emqx:5.5.1 |
+| Порты | 1883 (MQTT), 8083 (WebSocket), 18083 (Dashboard) |
+| Auth | HTTP POST -> iot-operator:9090/internal/mqtt/auth |
+| ACL | HTTP POST -> iot-operator:9090/internal/mqtt/acl |
+| Конфиг | HOCON emqx.conf через ConfigMap |
+
+---
+
+## CRD: IoTDevice (iot.kube5s.ru/v1alpha1)
+
+### Spec
+
+| Поле | Тип | Обязательное | Описание |
+|------|-----|-------------|----------|
+| deviceId | string | да | Pattern: ^[a-z0-9][a-z0-9-]*[a-z0-9]$ |
+| enabled | bool | нет | default: true |
+| metadata | map[string]string | нет | Произвольные метаданные |
+
+### Status
+
+| Поле | Описание |
+|------|----------|
+| phase | Active / Disabled / Pending / Error |
+| mqttUsername | {namespace}_{deviceId} |
+| secretName | iot-{deviceId} |
+| topicPrefix | {namespace}/ |
+| message | Сообщение об ошибке |
+
+### Reconcile logic
+
+1. Добавить finalizer iot.kube5s.ru/device-cleanup
+2. Если Secret iot-{deviceId} не существует:
+   - crypto/rand 32 bytes -> hex (64 символа) = пароль
+   - Создать Secret с OwnerReference -> каскадное удаление
+   - Keys: mqtt-username, mqtt-password, device-id
+3. Status: phase=Active, mqttUsername={ns}_{deviceId}
+4. Если enabled=false -> phase=Disabled (Secret НЕ удаляется)
+5. DELETE: finalizer cleanup -> Secret удаляется каскадно
+
+---
+
+## Аутентификация
+
+### REST API (/v1/)
+
+- Middleware: Bearer JWT token
+- authTestMode = true (текущий): любой непустой Bearer token принимается
+- authTestMode = false (prod): JWT decode -> sub -> SHA256 -> namespace mapping
+
+### MQTT Auth (/internal/mqtt/auth)
+
+1. Если username == BridgeUsername -> проверить BridgePassword -> allow/deny
+2. Иначе: парсить username по первому "_" -> namespace + deviceId
+3. Найти Secret iot-{deviceId} в namespace
+4. crypto/subtle.ConstantTimeCompare(password, secret.mqtt-password)
+5. Всегда HTTP 200, body: {"result": "allow"} или {"result": "deny"}
+
+### MQTT ACL (/internal/mqtt/acl)
+
+- Bridge (clientid=sless-iot-bridge): allow subscribe +/telemetry/+
+- Device: allow pub/sub только {namespace}/telemetry/{deviceId}
+- Всё остальное: deny
+
+---
+
+## Хранение данных
+
+### PostgreSQL (managed)
+
+| Параметр | Значение |
+|----------|----------|
+| Версия | PG 17 |
+| Host | postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local |
+| User | super |
+| Master DB | sqsdb |
+
+Per-tenant изоляция: отдельная DATABASE tenant_{namespace}.
+
+Таблица iot_telemetry:
+- id SERIAL PRIMARY KEY
+- device_id TEXT NOT NULL
+- payload JSONB NOT NULL
+- received_at TIMESTAMPTZ
+- created_at TIMESTAMPTZ DEFAULT NOW()
+
+### shared-SQS
+
+| Параметр | Значение |
+|----------|----------|
+| Endpoint | https://qu.kube5s.ru |
+| Tenant | iot-service (t-96afe7e9f781f6ca) |
+| Queue | iot-telemetry |
+| Протокол | AWS SQS API compatible |
+
+---
+
+## Docker образ
+
+- Registry: Docker Hub naeel/iot-operator
+- Базовый: gcr.io/distroless/static:nonroot
+- Содержит 3 бинарника: /iot-operator, /mqtt-bridge, /sqs-consumer
+- Выбор бинарника через command в Deployment YAML
+
+---
+
+## Сетевая схема
+
+```
+Internet
+    |
+    v
+nginx-ingress (namespace ingress)
+    | iot.kube5s.ru/mqtt -> emqx-ws:8083 (WebSocket)
+    | iot.kube5s.ru/console -> iot-operator:9090 (UI)
+    | iot.kube5s.ru/iot-admin -> iot-operator:9090 (Admin UI)
+    v
+namespace sless:
+    emqx:1883 <-> iot-mqtt-bridge (MQTT)
+    emqx:1883 <- IoT devices (MQTT)
+    iot-operator:9090 <- emqx (auth/acl HTTP)
+    iot-operator:9090 <- users (REST API)
+    iot-mqtt-bridge -> shared-sqs (HTTPS, SQS API)
+    iot-sqs-consumer <- shared-sqs (HTTPS, SQS API)
+    iot-sqs-consumer -> managed-postgres (TCP 5432)
+    iot-operator -> managed-postgres (TCP 5432, telemetry GET)
+    iot-operator -> k8s API (CRD watch, Secret CRUD)
+
+namespace shared-sqs:
+    shared-sqs:9324 (SQS API)
+    Ingress: qu.kube5s.ru -> shared-sqs
+
+namespace dc5db45d-...:
+    postgresqlk8s-0 (PG 17 managed)
+```
+
+---
+
+## Секреты (namespace sless)
+
+| Secret | Ключи | Используется |
+|--------|-------|-------------|
+| iot-bridge-credentials | MQTT_USERNAME, MQTT_PASSWORD | iot-operator, iot-mqtt-bridge |
+| iot-sqs-credentials | SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY | iot-mqtt-bridge, iot-sqs-consumer |
+| iot-postgres-secret | IOT_PG_DSN | iot-sqs-consumer |
+
+---
+
+## Эволюция архитектуры
+
+| Версия | Дата | Message bus | Postgres | Кластер |
+|--------|------|------------|----------|---------|
+| v0.1.50 | 2026-04-04 | RabbitMQ (AMQP) | emptyDir PVC | sless (общий) |
+| v0.1.68 | 2026-04-06 | Kafka (segmentio/kafka-go) | emptyDir PVC | sless (общий) |
+| v0.2.0 | 2026-04-12 | shared-SQS (AWS SDK) | Managed PG 17 | iot-naeel (новый) |
+| v0.2.3 | 2026-04-12 | shared-SQS (AWS SDK) | Managed PG 17 | iot-naeel |

legacy/doc/architecture/overview.md

@@ -0,0 +1,236 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# IoT Managed Service — Архитектура
+
+## Общая схема
+
+```
+IoT Device (MQTT CONNECT)
+    │ username="{ns}_{deviceId}", password=hex
+    ▼
+EMQX 5.5.1 (sless/emqx)
+    │ POST /internal/mqtt/auth → iot-operator:9090
+    │ POST /internal/mqtt/acl  → iot-operator:9090
+    ▼
+    │ MQTT PUBLISH → topic: "{ns}/telemetry/{deviceId}"
+    ▼
+iot-mqtt-bridge (cmd/mqtt-bridge)
+    │ подписка на "+/telemetry/+"
+    │ → Kafka topic "iot.telemetry"
+    ▼
+Kafka
+    ▼
+iot-kafka-consumer (cmd/kafka-consumer)
+    │ consumer group "iot-pg-consumer"
+    │ → per-tenant Postgres DB
+    ▼
+IoT Postgres (iot-postgres.sless.svc)
+    │ DB: tenant_{namespace}
+    │ Table: iot_telemetry
+    ▼
+REST API (iot-operator:9090)
+    │ GET /v1/namespaces/{ns}/iot/telemetry
+    ▼
+Пользователь (Terraform / UI Console)
+```
+
+## Компоненты
+
+| Компонент | Бинарник | Порт | Назначение |
+|-----------|----------|------|------------|
+| iot-operator | cmd/iot-operator | :9090 (API), :8081 (health) | Controller-manager + REST API |
+| mqtt-bridge | cmd/mqtt-bridge | — | MQTT→Kafka bridge |
+| kafka-consumer | cmd/kafka-consumer | — | Kafka→Postgres pipeline |
+
+## CRD
+
+- **IoTDevice** (`iot.kube5s.ru/v1alpha1`)
+  - Создание: пользователь через API / Terraform
+  - Controller генерирует MQTT credentials → k8s Secret
+  - Secret удаляется каскадно через OwnerReference
+
+## Хранение
+
+- **IoT Postgres** — отдельный от sless PG
+  - Management DB: `iot_platform` (таблица `tenant_credentials`)
+  - Per-tenant DB: `tenant_{namespace}` (таблица `iot_telemetry`)
+
+## Аутентификация
+
+- REST API (/v1/): Bearer JWT (middleware.Auth)
+- MQTT Auth (/internal/): вызывается EMQX, без JWT
+- Admin (/iot-admin/stats): ADMIN_STATS_TOKEN
+
+## Docker образ
+
+- `naeel/iot-operator` (Docker Hub)
+- Все 3 бинарника в одном образе
+- `command: ["/iot-operator"]` или `["/mqtt-bridge"]` или `["/kafka-consumer"]`
+
+---
+
+## Актуальная архитектура (2026-04-12)
+
+> Kafka заменён на shared-SQS. Postgres заменён на managed. Новый кластер iot-naeel.
+
+### Текущая схема
+
+```
+IoT Device (MQTT CONNECT)
+    │ username="{ns}_{deviceId}", password=hex
+    ▼
+EMQX 5.5.1 (sless/emqx)
+    │ POST /internal/mqtt/auth → iot-operator:9090
+    │ POST /internal/mqtt/acl  → iot-operator:9090
+    ▼
+    │ MQTT PUBLISH → topic: "{ns}/telemetry/{deviceId}"
+    ▼
+iot-mqtt-bridge (cmd/mqtt-bridge)
+    │ подписка на "+/telemetry/+"
+    │ → AWS SDK SQS SendMessage → shared-SQS (https://qu.kube5s.ru)
+    │ очередь: "iot-telemetry" (tenant: iot-service, id: t-96afe7e9f781f6ca)
+    ▼
+shared-SQS (namespace shared-sqs)
+    │ AWS SQS-совместимый, multi-tenant
+    ▼
+iot-sqs-consumer (cmd/sqs-consumer)
+    │ ReceiveMessage (WaitTimeSeconds=20, long polling)
+    │ DeleteMessage после успешной записи (at-least-once)
+    │ → per-tenant Postgres DB
+    ▼
+Managed PostgreSQL 17 (namespace dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5)
+    │ Host: postgresqlk8s-master.dc5db45d-....svc.cluster.local
+    │ User: super, DB: sqsdb
+    │ Per-tenant DB: tenant_{namespace}, Table: iot_telemetry
+    ▼
+REST API (iot-operator:9090)
+    │ GET /v1/namespaces/{ns}/iot/telemetry
+    ▼
+Пользователь (Terraform / UI Console)
+    │ wss://iot.kube5s.ru/mqtt (WebSocket через Ingress)
+    │ https://iot.kube5s.ru/console (UI)
+```
+
+### Компоненты (актуальные)
+
+| Компонент | Бинарник | Порт | Назначение |
+|-----------|----------|------|------------|
+| iot-operator | cmd/iot-operator | :9090 (API), :8080 (metrics), :8081 (health) | Controller-manager + REST API |
+| mqtt-bridge | cmd/mqtt-bridge | — | MQTT → shared-SQS bridge |
+| sqs-consumer | cmd/sqs-consumer | — | shared-SQS → Postgres pipeline |
+
+### Инфраструктура
+
+| Сервис | Тип | Namespace | Описание |
+|--------|-----|-----------|----------|
+| EMQX 5.5.1 | В кластере | sless | MQTT-брокер, HTTP auth/acl → iot-operator |
+| shared-SQS | В кластере | shared-sqs | AWS SQS-совместимая очередь, endpoint https://qu.kube5s.ru |
+| PostgreSQL 17 | Managed (оператор) | dc5db45d-... | per-tenant DB, тот же инстанс что и SQS billing |
+| cert-manager | В кластере | cert-manager | TLS сертификаты для iot.kube5s.ru |
+| nginx-ingress | В кластере | ingress | WSS/HTTPS проксирование |
+
+### Секреты в namespace sless
+
+| Secret | Ключи | Источник |
+|--------|-------|----------|
+| iot-sqs-credentials | SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY | shared-SQS tenant iot-service |
+| iot-postgres-secret | POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB, IOT_PG_DSN | Managed PG |
+| iot-bridge-credentials | MQTT_USERNAME, MQTT_PASSWORD | Для mqtt-bridge → EMQX |
+
+### Docker образ (актуальный)
+
+- `naeel/iot-operator:v0.2.0` (Docker Hub)
+- Все 3 бинарника в одном образе
+- `command: ["/iot-operator"]` или `["/mqtt-bridge"]` или `["/sqs-consumer"]`
+- Базовый: `gcr.io/distroless/static:nonroot`
+
+### Кластер
+
+- Имя: `iot-naeel`
+- API: `https://185.247.187.149:6443`
+- Ingress IP: `185.247.187.151`
+- DNS: `iot.kube5s.ru → 185.247.187.147`
+
+---
+
+## Актуальная архитектура (2026-04-12)
+
+> Kafka заменён на shared-SQS. Postgres заменён на managed. Новый кластер iot-naeel.
+
+### Текущая схема
+
+```
+IoT Device (MQTT CONNECT)
+    │ username="{ns}_{deviceId}", password=hex
+    ▼
+EMQX 5.5.1 (sless/emqx)
+    │ POST /internal/mqtt/auth → iot-operator:9090
+    │ POST /internal/mqtt/acl  → iot-operator:9090
+    ▼
+    │ MQTT PUBLISH → topic: "{ns}/telemetry/{deviceId}"
+    ▼
+iot-mqtt-bridge (cmd/mqtt-bridge)
+    │ подписка на "+/telemetry/+"
+    │ → AWS SDK SQS SendMessage → shared-SQS (https://qu.kube5s.ru)
+    │ очередь: "iot-telemetry" (tenant: iot-service, id: t-96afe7e9f781f6ca)
+    ▼
+shared-SQS (namespace shared-sqs)
+    │ AWS SQS-совместимый, multi-tenant
+    ▼
+iot-sqs-consumer (cmd/sqs-consumer)
+    │ ReceiveMessage (WaitTimeSeconds=20, long polling)
+    │ DeleteMessage после успешной записи (at-least-once)
+    │ → per-tenant Postgres DB
+    ▼
+Managed PostgreSQL 17 (namespace dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5)
+    │ Host: postgresqlk8s-master.dc5db45d-....svc.cluster.local
+    │ User: super, DB: sqsdb
+    │ Per-tenant DB: tenant_{namespace}, Table: iot_telemetry
+    ▼
+REST API (iot-operator:9090)
+    │ GET /v1/namespaces/{ns}/iot/telemetry
+    ▼
+Пользователь (Terraform / UI Console)
+    │ wss://iot.kube5s.ru/mqtt (WebSocket через Ingress)
+    │ https://iot.kube5s.ru/console (UI)
+```
+
+### Компоненты (актуальные)
+
+| Компонент | Бинарник | Порт | Назначение |
+|-----------|----------|------|------------|
+| iot-operator | cmd/iot-operator | :9090 (API), :8080 (metrics), :8081 (health) | Controller-manager + REST API |
+| mqtt-bridge | cmd/mqtt-bridge | — | MQTT → shared-SQS bridge |
+| sqs-consumer | cmd/sqs-consumer | — | shared-SQS → Postgres pipeline |
+
+### Инфраструктура
+
+| Сервис | Тип | Namespace | Описание |
+|--------|-----|-----------|----------|
+| EMQX 5.5.1 | В кластере | sless | MQTT-брокер, HTTP auth/acl → iot-operator |
+| shared-SQS | В кластере | shared-sqs | AWS SQS-совместимая очередь, endpoint https://qu.kube5s.ru |
+| PostgreSQL 17 | Managed (оператор) | dc5db45d-... | per-tenant DB, тот же инстанс что и SQS billing |
+| cert-manager | В кластере | cert-manager | TLS сертификаты для iot.kube5s.ru |
+| nginx-ingress | В кластере | ingress | WSS/HTTPS проксирование |
+
+### Секреты в namespace sless
+
+| Secret | Ключи | Источник |
+|--------|-------|----------|
+| iot-sqs-credentials | SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY | shared-SQS tenant iot-service |
+| iot-postgres-secret | POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB, IOT_PG_DSN | Managed PG |
+| iot-bridge-credentials | MQTT_USERNAME, MQTT_PASSWORD | Для mqtt-bridge → EMQX |
+
+### Docker образ (актуальный)
+
+- `naeel/iot-operator:v0.2.0` (Docker Hub)
+- Все 3 бинарника в одном образе
+- `command: ["/iot-operator"]` или `["/mqtt-bridge"]` или `["/sqs-consumer"]`
+- Базовый: `gcr.io/distroless/static:nonroot`
+
+### Кластер
+
+- Имя: `iot-naeel`
+- API: `https://185.247.187.149:6443`
+- Ingress IP: `185.247.187.151`
+- DNS: `iot.kube5s.ru → 185.247.187.147`

legacy/doc/decisions/2026-04-12-replace-kafka-with-sqs.md

@@ -0,0 +1,79 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# Решение: замена Kafka на shared-SQS
+
+**Дата:** 2026-04-12  
+**Статус:** в работе  
+**Ветка:** `feature/replace-kafka-with-sqs`
+
+---
+
+## Контекст
+
+IoT-сервис использует Kafka (библиотека `segmentio/kafka-go`) как промежуточную очередь между MQTT-bridge и Postgres consumer.  
+Kafka — тяжёлый компонент: требует отдельный деплоймент в кластере (`deployments/k8s/kafka.yaml`), ZooKeeper/KRaft, настройку топиков, партиций.
+
+У нас есть собственный сервис **shared-SQS** — AWS SQS-совместимая очередь сообщений:
+- Репа: https://gitea.services.ngcloud.ru/Nail/shared-SQS
+- Endpoint: `https://qu.kube5s.ru`
+- 17 SQS-операций, multi-tenant, Redis persistence, billing
+- Работает через стандартные AWS SDK
+
+RabbitMQ в коде IoT **не используется** (только в старых документах как план MVP).
+
+---
+
+## Решение
+
+Заменить Kafka → shared-SQS во всём IoT pipeline.
+
+---
+
+## Что меняется
+
+### 1. mqtt-bridge (`cmd/mqtt-bridge/main.go`)
+- **Было:** `kafka.Writer` → `WriteMessages()` в топик `iot.telemetry`
+- **Стало:** AWS SDK Go v2 → `sqs.SendMessage()` в очередь `iot-telemetry`
+- Env: `KAFKA_BROKERS` → `SQS_ENDPOINT`, `SQS_ACCESS_KEY`, `SQS_SECRET_KEY`, `SQS_QUEUE_NAME`
+
+### 2. kafka-consumer → sqs-consumer (`cmd/kafka-consumer/` → `cmd/sqs-consumer/`)
+- **Было:** `kafka.NewReader` с consumer group, `FetchMessage()` + `CommitMessages()`
+- **Стало:** polling loop: `sqs.ReceiveMessage(WaitTimeSeconds=20)` + `sqs.DeleteMessage()`
+- Переименовать директорию и бинарник
+
+### 3. admin stats handler (`internal/api/handler/iot_admin_stats_handler.go`)
+- **Было:** Kafka lag (ListOffsets + OffsetFetch)
+- **Стало:** `sqs.GetQueueAttributes(ApproximateNumberOfMessages, ApproximateNumberOfMessagesNotVisible)`
+- Env: `KAFKA_BROKERS` → SQS credentials в handler
+
+### 4. go.mod
+- Убрать: `github.com/segmentio/kafka-go`
+- Добавить: `github.com/aws/aws-sdk-go-v2`, `github.com/aws/aws-sdk-go-v2/service/sqs`
+
+### 5. Deployments
+- Удалить: `deployments/k8s/kafka.yaml`
+- Обновить: `deployments/k8s/iot-mqtt-bridge.yaml` — новые env vars
+- Обновить: `deployments/k8s/iot-kafka-consumer.yaml` → `iot-sqs-consumer.yaml`
+
+### 6. Dockerfile / Makefile
+- Переименовать бинарник `kafka-consumer` → `sqs-consumer`
+
+---
+
+## Плюсы
+
+- Убираем Kafka из кластера (экономия ресурсов)
+- Используем свой managed сервис (единая инфраструктура)
+- AWS SDK — стандартная библиотека, код проще
+- Billing и мониторинг из коробки в shared-SQS
+
+## Риски
+
+- SQS — pull-based (polling latency до 20s long poll vs Kafka push). Для IoT телеметрии приемлемо.
+- At-least-once delivery — нужно учитывать idempotency (уже есть в текущем коде: INSERT ON CONFLICT)
+
+---
+
+## SQS endpoint
+
+Пока используем публичный `https://qu.kube5s.ru`. Если есть внутрикластерный сервис — обновим.

legacy/doc/decisions/2026-04-12-separate-repo.md

@@ -1,3 +1,5 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
 # Решение: Вынос IoT в отдельную репу
 
 **Дата:** 2026-04-12

legacy/doc/deployment-v0.2.3.md

@@ -0,0 +1,297 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# IoT Managed Service — Актуальный деплой (v0.2.3)
+
+> Дата: 2026-04-12
+> Образ: `naeel/iot-operator:v0.2.3`
+> Ветка: `feature/replace-kafka-with-sqs`
+> Кластер: `iot-naeel`
+> Автор: GitHub Copilot (Claude Opus 4.6)
+
+---
+
+## Обзор
+
+Три бинарника из одного Docker-образа `naeel/iot-operator:v0.2.3`:
+
+| Бинарник | Deployment | Назначение |
+|----------|-----------|------------|
+| `/iot-operator` | iot-operator | Controller-manager (IoTDevice CRD) + REST API :9090 |
+| `/mqtt-bridge` | iot-mqtt-bridge | MQTT (EMQX) → shared-SQS bridge |
+| `/sqs-consumer` | iot-sqs-consumer | shared-SQS → Postgres pipeline |
+
+Плюс:
+- EMQX 5.5.1 — MQTT-брокер (отдельный образ `emqx/emqx:5.5.1`)
+
+---
+
+## Кластер
+
+| Параметр | Значение |
+|----------|----------|
+| Имя | `iot-naeel` |
+| API | `https://185.247.187.149:6443` |
+| Ingress IP | `185.247.187.151` |
+| DNS | `iot.kube5s.ru → 185.247.187.147` |
+| Namespace | `sless` |
+| kubeconfig | `~/.kube/config` на ВМ (токен 24ч, обновлять через auth.k8s.ngcloud.ru) |
+
+---
+
+## Секреты (namespace sless)
+
+Перед первым деплоем создать 3 секрета:
+
+### 1. iot-bridge-credentials (MQTT bridge → EMQX)
+
+```bash
+kubectl create secret generic iot-bridge-credentials -n sless \
+  --from-literal=MQTT_USERNAME="iot-bridge-internal" \
+  --from-literal=MQTT_PASSWORD="<пароль bridge>"
+```
+
+Используется:
+- **iot-operator** — для проверки bridge auth в `/internal/mqtt/auth` (env: MQTT_BRIDGE_USERNAME, MQTT_BRIDGE_PASSWORD)
+- **iot-mqtt-bridge** — для подключения к EMQX (envFrom: secretRef)
+
+### 2. iot-sqs-credentials (shared-SQS)
+
+```bash
+kubectl create secret generic iot-sqs-credentials -n sless \
+  --from-literal=SQS_ENDPOINT="https://qu.kube5s.ru" \
+  --from-literal=SQS_ACCESS_KEY="SSAK-a9964f2723bc6d347f48d153" \
+  --from-literal=SQS_SECRET_KEY="<secret_key>"
+```
+
+Используется:
+- **iot-mqtt-bridge** — для SendMessage
+- **iot-sqs-consumer** — для ReceiveMessage + DeleteMessage
+
+### 3. iot-postgres-secret (Managed PostgreSQL)
+
+```bash
+kubectl create secret generic iot-postgres-secret -n sless \
+  --from-literal=IOT_PG_DSN="postgres://super:<password>@postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local:5432/sqsdb?sslmode=disable"
+```
+
+Используется:
+- **iot-sqs-consumer** — для записи телеметрии в per-tenant DB
+
+---
+
+## Процедура деплоя (пошагово)
+
+### Все команды выполнять на ВМ через SSH
+
+```bash
+ssh -i ~/.ssh/id_ed25519 naeel@5.172.178.213
+cd /home/naeel/terra/IoT
+```
+
+### 0. Сборка образа (если код менялся)
+
+```bash
+docker build --no-cache -t naeel/iot-operator:v0.2.3 .
+docker push naeel/iot-operator:v0.2.3
+```
+
+### 1. CRD (один раз, cluster-wide)
+
+```bash
+kubectl apply -f config/crd/bases/iot.kube5s.ru_iotdevices.yaml
+```
+
+### 2. EMQX
+
+```bash
+kubectl apply -f deployments/k8s/emqx.yaml
+kubectl apply -f deployments/k8s/emqx-ws-ingress.yaml
+```
+
+### 3. Postgres secret (один раз)
+
+```bash
+kubectl apply -f deployments/k8s/iot-postgres.yaml
+```
+
+### 4. SQS secret (один раз)
+
+```bash
+kubectl get secret iot-sqs-credentials -n sless
+# Если нет — создать (см. секцию Секреты выше)
+```
+
+### 5. Bridge credentials (один раз)
+
+```bash
+kubectl get secret iot-bridge-credentials -n sless
+# Если нет — создать (см. секцию Секреты выше)
+```
+
+### 6. Operator
+
+```bash
+kubectl apply -f deployments/k8s/iot-operator.yaml
+kubectl rollout status deployment/iot-operator -n sless
+```
+
+### 7. MQTT Bridge
+
+```bash
+kubectl apply -f deployments/k8s/iot-mqtt-bridge.yaml
+kubectl rollout status deployment/iot-mqtt-bridge -n sless
+```
+
+### 8. SQS Consumer
+
+```bash
+kubectl apply -f deployments/k8s/iot-sqs-consumer.yaml
+kubectl rollout status deployment/iot-sqs-consumer -n sless
+```
+
+### 9. Проверка
+
+```bash
+kubectl get pods -n sless
+# Ожидаемый результат:
+# emqx-xxx              1/1 Running
+# iot-operator-xxx      1/1 Running
+# iot-mqtt-bridge-xxx   1/1 Running
+# iot-sqs-consumer-xxx  1/1 Running
+
+kubectl logs -n sless deployment/iot-operator --tail=5
+kubectl logs -n sless deployment/iot-mqtt-bridge --tail=5
+kubectl logs -n sless deployment/iot-sqs-consumer --tail=5
+```
+
+---
+
+## Обновление образа (rollout)
+
+```bash
+# 1. Собрать новый образ
+docker build --no-cache -t naeel/iot-operator:v0.2.4 .
+docker push naeel/iot-operator:v0.2.4
+
+# 2. Обновить тег во ВСЕХ трёх YAML
+sed -i 's/v0.2.3/v0.2.4/g' deployments/k8s/iot-operator.yaml \
+  deployments/k8s/iot-mqtt-bridge.yaml \
+  deployments/k8s/iot-sqs-consumer.yaml
+
+# 3. Применить
+kubectl apply -f deployments/k8s/iot-operator.yaml
+kubectl apply -f deployments/k8s/iot-mqtt-bridge.yaml
+kubectl apply -f deployments/k8s/iot-sqs-consumer.yaml
+
+# 4. Проверить
+kubectl get pods -n sless -w
+```
+
+**ВАЖНО:** Если образ с тем же тегом — Kubernetes не скачает новый (кэш на нодах). Всегда менять тег.
+
+---
+
+## Компоненты: env vars
+
+### iot-operator
+
+| Переменная | Значение | Источник |
+|-----------|----------|----------|
+| MQTT_BRIDGE_USERNAME | iot-bridge-internal | Secret iot-bridge-credentials (key: MQTT_USERNAME) |
+| MQTT_BRIDGE_PASSWORD | (пароль) | Secret iot-bridge-credentials (key: MQTT_PASSWORD) |
+
+### iot-mqtt-bridge
+
+| Переменная | Значение | Источник |
+|-----------|----------|----------|
+| MQTT_BROKER_URL | tcp://emqx.sless.svc:1883 | YAML env |
+| SQS_QUEUE_NAME | iot-telemetry | YAML env |
+| SQS_REGION | us-east-1 | YAML env |
+| MQTT_USERNAME | iot-bridge-internal | Secret iot-bridge-credentials |
+| MQTT_PASSWORD | (пароль) | Secret iot-bridge-credentials |
+| SQS_ENDPOINT | https://qu.kube5s.ru | Secret iot-sqs-credentials |
+| SQS_ACCESS_KEY | SSAK-... | Secret iot-sqs-credentials |
+| SQS_SECRET_KEY | (secret) | Secret iot-sqs-credentials |
+
+### iot-sqs-consumer
+
+| Переменная | Значение | Источник |
+|-----------|----------|----------|
+| SQS_QUEUE_NAME | iot-telemetry | YAML env |
+| SQS_REGION | us-east-1 | YAML env |
+| SQS_ENDPOINT | https://qu.kube5s.ru | Secret iot-sqs-credentials |
+| SQS_ACCESS_KEY | SSAK-... | Secret iot-sqs-credentials |
+| SQS_SECRET_KEY | (secret) | Secret iot-sqs-credentials |
+| IOT_PG_DSN | postgres://... | Secret iot-postgres-secret |
+
+---
+
+## Managed PostgreSQL
+
+| Параметр | Значение |
+|---------|----------|
+| Версия | PostgreSQL 17 |
+| Host | postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local |
+| Port | 5432 |
+| User | super |
+| DB | sqsdb |
+| Тип | Managed (оператор в другом namespace) |
+
+Per-tenant изоляция: для каждого namespace создаётся отдельная DATABASE `tenant_{namespace}` с таблицей `iot_telemetry`.
+
+---
+
+## shared-SQS (очередь)
+
+| Параметр | Значение |
+|---------|----------|
+| Endpoint | https://qu.kube5s.ru |
+| Tenant | iot-service (ID: t-96afe7e9f781f6ca) |
+| Очередь | iot-telemetry |
+| Протокол | AWS SQS API (AWS SDK compatible) |
+
+---
+
+## Версии образов (история)
+
+| Версия | Дата | Изменения |
+|--------|------|-----------|
+| v0.2.3 | 2026-04-12 | Bridge auth fix (BridgeUsername/BridgePassword), debug logs |
+| v0.2.2 | 2026-04-12 | Bridge auth (первая попытка, проблема с табами) |
+| v0.2.1 | 2026-04-12 | Bridge auth (проблема IsSuperuser field) |
+| v0.2.0 | 2026-04-12 | Kafka->SQS, managed PG, новый кластер iot-naeel |
+| v0.1.69 | 2026-04-06 | Kafka Async write fix (1000/1000 тест) |
+| v0.1.68 | 2026-04-06 | Kafka pipeline (bridge->Kafka->consumer->Postgres) |
+| v0.1.50 | 2026-04-04 | Первый IoT: controller + API + mqtt-bridge (RabbitMQ) |
+
+---
+
+## Известные ошибки и решения (v0.2.x)
+
+### mqtt-bridge: MQTT connect timeout / CrashLoopBackOff
+
+**Симптом:** bridge не подключается к EMQX, логи "MQTT connect timeout"
+
+**Причина:** EMQX вызывает `/internal/mqtt/auth` при CONNECT. Bridge username `iot-bridge-internal` не содержит `_` -> MQTTAuth парсит namespace_deviceId -> ошибка -> deny -> EMQX возвращает not_authorized -> bridge retry 30с -> выглядит как timeout.
+
+**Решение (v0.2.3):** В Handler добавлены поля BridgeUsername/BridgePassword. MQTTAuth проверяет bridge credentials ДО парсинга namespace_deviceId. Если username совпадает — allow.
+
+### Docker image cache на k8s нодах
+
+**Симптом:** после `docker push` новый образ не используется, pod стартует со старым кодом.
+
+**Причина:** imagePullPolicy=Always работает, но если тег не изменился Kubernetes может использовать кэш ноды.
+
+**Решение:** Всегда менять тег при пересборке (v0.2.1 -> v0.2.2 -> v0.2.3 и т.д.)
+
+### EMQX: required_field node.cookie/node.data_dir
+
+**Симптом:** EMQX CrashLoopBackOff при первом старте
+
+**Причина:** EMQX 5.x требует явных node.cookie и node.data_dir
+
+**Решение:** В emqx.conf (ConfigMap) обязательны:
+```hocon
+node { name = "emqx@127.0.0.1", cookie = "...", data_dir = "/opt/emqx/data" }
+```
+После изменения ConfigMap: `kubectl rollout restart deployment/emqx -n sless`

legacy/doc/deployment.md

@@ -1,3 +1,5 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
 # IoT MVP — Инженерная документация деплоя
 
 > Создано: 2026-04-04  
@@ -304,3 +306,101 @@ node {
 |--------|------|-----------|
 | v0.1.50 | 2026-04-04 | IoT controller + IoT API + iot-mqtt-bridge бинарь |
 | v0.1.49 | ранее | До IoT |
+
+---
+
+## Актуальный деплой (2026-04-12)
+
+> Кластер: iot-naeel (новый). Kafka удалён. Postgres — managed. SQS вместо Kafka.
+
+### Кластер iot-naeel
+
+- API: `https://185.247.187.149:6443`
+- Ingress IP: `185.247.187.151`
+- DNS: `iot.kube5s.ru → 185.247.187.147`
+- kubeconfig: `~/.kube/config` на ВМ (токен с TTL 24ч, обновляется через auth.k8s.ngcloud.ru)
+
+### Namespace sless — содержимое
+
+| Ресурс | Имя | Описание |
+|--------|-----|----------|
+| Deployment | emqx | MQTT-брокер EMQX 5.5.1 |
+| Deployment | iot-operator | Controller-manager + REST API v0.2.0 |
+| Deployment | iot-mqtt-bridge | MQTT → shared-SQS bridge v0.2.0 |
+| Deployment | iot-sqs-consumer | shared-SQS → Postgres consumer v0.2.0 |
+| Service | emqx | :1883 (MQTT), :8083 (WS), :18083 (dashboard) |
+| Service | emqx-ws | :8083 (для Ingress) |
+| Service | iot-operator | :9090 (REST API) |
+| Ingress | emqx-mqtt-websocket | iot.kube5s.ru → /mqtt (WS), /console (UI) |
+| Secret | iot-sqs-credentials | SQS_ENDPOINT, SQS_ACCESS_KEY, SQS_SECRET_KEY |
+| Secret | iot-postgres-secret | POSTGRES_USER, POSTGRES_PASSWORD, IOT_PG_DSN |
+| Secret | iot-bridge-credentials | MQTT_USERNAME, MQTT_PASSWORD |
+| CRD | iotdevices.iot.kube5s.ru | IoTDevice v1alpha1 |
+| ServiceAccount | iot-operator | + ClusterRole + ClusterRoleBinding |
+
+### Процедура деплоя (актуальная)
+
+```bash
+# 0. SSH на ВМ (все команды оттуда)
+ssh -i ~/.ssh/id_ed25519 naeel@5.172.178.213
+
+# 1. Сборка и push образа
+cd /home/naeel/terra/IoT
+docker build -t naeel/iot-operator:v0.2.0 -t naeel/iot-operator:latest .
+docker push naeel/iot-operator:v0.2.0
+docker push naeel/iot-operator:latest
+
+# 2. CRD (один раз)
+kubectl apply -f config/crd/bases/iot.kube5s.ru_iotdevices.yaml
+
+# 3. Postgres Secret (содержит DSN managed PG)
+kubectl apply -f deployments/k8s/iot-postgres.yaml
+
+# 4. EMQX
+kubectl apply -f deployments/k8s/emqx.yaml
+kubectl apply -f deployments/k8s/emqx-ws-ingress.yaml
+
+# 5. Operator
+kubectl apply -f deployments/k8s/iot-operator.yaml
+
+# 6. SQS credentials (уже создан через kubectl create secret)
+# kubectl get secret iot-sqs-credentials -n sless
+
+# 7. MQTT bridge credentials (уже создан)
+# kubectl get secret iot-bridge-credentials -n sless
+
+# 8. Bridge + Consumer
+kubectl apply -f deployments/k8s/iot-mqtt-bridge.yaml
+kubectl apply -f deployments/k8s/iot-sqs-consumer.yaml
+
+# 9. Проверка
+kubectl get pods -n sless
+kubectl logs -n sless deployment/iot-operator --tail=10
+kubectl logs -n sless deployment/iot-mqtt-bridge --tail=10
+kubectl logs -n sless deployment/iot-sqs-consumer --tail=10
+```
+
+### Managed PostgreSQL
+
+- Namespace: `dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5`
+- Pod: `postgresqlk8s-0`
+- Host: `postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local`
+- User: `super`, DB: `sqsdb`, PG 17
+- Тот же инстанс что использует shared-SQS для billing
+- Credentials: см. `/home/naeel/terra/SQS-service/secrets/iot_pg.md`
+
+### shared-SQS (очередь вместо Kafka)
+
+- Namespace: `shared-sqs`
+- Endpoint: `https://qu.kube5s.ru`
+- Tenant ID: `t-96afe7e9f781f6ca` (iot-service)
+- Queue: `iot-telemetry`
+- Access Key: хранится в Secret `iot-sqs-credentials` namespace `sless`
+- Admin token: хранится в Secret `shared-sqs-admin` namespace `shared-sqs`
+
+### Версии образов (актуальные)
+
+| Версия | Дата | Registry | Изменения |
+|--------|------|----------|-----------|
+| v0.2.0 | 2026-04-12 | Docker Hub naeel/iot-operator | Kafka→SQS, managed PG, новый кластер |
+| v0.1.50 | 2026-04-04 | pearlharbor (Harbor) | IoT controller + API + mqtt-bridge (Kafka) |

legacy/doc/iot-mvp-plan.md

@@ -1,3 +1,5 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
 # IoT MVP — План реализации для Sonnet
 
 > **Автор плана**: GitHub Copilot (Claude Opus 4.6)  

legacy/doc/progress.md

@@ -0,0 +1,141 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# IoT Managed Service — Трекер прогресса
+
+## 2026-04-12: Перенос из sless в отдельную репу
+
+### Выполнено
+- [x] Создана репа https://gitea.services.ngcloud.ru/Nail/IoT
+- [x] Go модуль: `gitea.services.ngcloud.ru/Nail/IoT`
+- [x] Перенесены все IoT-компоненты из sless:
+  - `iot/api/v1alpha1/` → `api/v1alpha1/` (CRD types: IoTDevice)
+  - `iot/controllers/` → `controllers/` (IoTDevice reconciler)
+  - `iot/cmd/mqtt-bridge/` → `cmd/mqtt-bridge/` (MQTT→Kafka)
+  - `iot/cmd/kafka-consumer/` → `cmd/kafka-consumer/` (Kafka→Postgres)
+  - `internal/storage/iotpg/` → `internal/storage/iotpg/` (per-tenant PG)
+  - `internal/api/handler/iot_*.go` → `internal/api/handler/` (REST handlers)
+  - `internal/api/ui/iot-*.html` → `internal/api/ui/` (embedded HTML)
+  - `internal/api/middleware/` → `internal/api/middleware/` (auth, logging)
+  - `deployments/k8s/iot-*.yaml` + `kafka.yaml` → `deployments/k8s/`
+  - `config/crd/bases/` → `config/crd/bases/`
+  - `doc/iot/`, `examples/IOT/` → `doc/`, `examples/`
+- [x] Созданы новые файлы:
+  - `cmd/iot-operator/main.go` — точка входа (controller-manager + REST API)
+  - `internal/api/handler/handler.go` — упрощённый Handler (без S3/PG от sless)
+  - `internal/api/router.go` — только IoT маршруты
+  - `Dockerfile` — multi-stage build, 3 бинарника, distroless
+  - `Makefile` — build/docker/deploy команды
+  - `.gitignore`
+  - `.github/copilot-instructions.md`
+- [x] Все import paths заменены: `sless/iot/...` → `Nail/IoT/...`
+- [x] Все 3 бинарника собираются без ошибок (go build ./...)
+- [x] Запушено в Gitea
+
+### Следующие шаги
+- [ ] Docker build + push на Docker Hub (`naeel/iot-operator`)
+- [ ] Обновить k8s manifests для нового образа
+- [ ] Деплой в кластер
+- [ ] E2E тест: создание устройства → MQTT → Kafka → Postgres → API
+- [ ] Убрать IoT-код из sless (опционально, после подтверждения что всё работает)
+
+---
+
+## 2026-04-12: Замена Kafka → shared-SQS + деплой в новый кластер
+
+### Выполнено
+- [x] Создана ветка `feature/replace-kafka-with-sqs`
+- [x] Документировано решение: `doc/decisions/2026-04-12-replace-kafka-with-sqs.md`
+- [x] **mqtt-bridge** (`cmd/mqtt-bridge/main.go`): Kafka Writer → AWS SDK SQS SendMessage
+- [x] **sqs-consumer** (`cmd/sqs-consumer/main.go`): новый — заменяет kafka-consumer, SQS ReceiveMessage → Postgres
+- [x] **kafka-consumer** (`cmd/kafka-consumer/`): удалён из кода
+- [x] **admin stats** (`internal/api/handler/iot_admin_stats_handler.go`): Kafka lag → SQS GetQueueAttributes
+- [x] **handler.go**: убрано поле KafkaBrokers
+- [x] **iot-operator/main.go**: убрана передача KAFKA_BROKERS
+- [x] go.mod: убран `segmentio/kafka-go`, добавлен `aws-sdk-go-v2` (v1.41.5 + sqs v1.42.25)
+- [x] Dockerfile: kafka-consumer → sqs-consumer
+- [x] Makefile: build-consumer → sqs-consumer
+- [x] .gitignore: исправлен баг (паттерны без `/` игнорировали `cmd/` директории)
+- [x] `go build ./...` проходит на ВМ
+- [x] Коммит и пуш в ветку
+
+### Деплой в кластер iot-naeel (новый кластер)
+- [x] shared-SQS: создан tenant `iot-service` (t-96afe7e9f781f6ca), очередь `iot-telemetry`
+- [x] Namespace `sless` создан
+- [x] Secret `iot-sqs-credentials` создан
+- [x] Secret `iot-bridge-credentials` создан
+- [x] Postgres: переключён на managed PG17 (тот же что SQS billing)
+- [x] Secret `iot-postgres-secret` создан (DSN → managed PG)
+- [x] Docker: собран и запушен `naeel/iot-operator:v0.2.0` в Docker Hub
+- [x] Deployment YAML: обновлены image на Docker Hub, убраны imagePullSecrets
+- [x] EMQX: задеплоен (emqx.yaml + emqx-ws-ingress.yaml, адаптирован из sless)
+- [x] iot-operator: задеплоен (новый iot-operator.yaml с RBAC)
+- [x] CRD `iotdevices.iot.kube5s.ru` установлен
+- [x] iot-mqtt-bridge: задеплоен, Running
+- [x] iot-sqs-consumer: задеплоен, Running — подключился к PG и SQS
+- [x] cert-manager: выпускает TLS для iot.kube5s.ru
+- [x] Коммит и пуш
+
+### Что работает
+- Все 4 пода Running 1/1
+- iot-operator: controller стартовал, MQTT auth/acl обрабатывает запросы от EMQX
+- sqs-consumer: подключился к Postgres и SQS, polling loop запущен
+- mqtt-bridge: подключён к EMQX и SQS, SQS queue resolved
+- EMQX: MQTT :1883, WS :8083, dashboard :18083
+
+### Следующие шаги
+- [ ] E2E тест: создание устройства → MQTT → SQS → Postgres → API
+- [ ] Нагрузочный тест
+- [ ] Мерж ветки в master
+- [ ] Убрать IoT-код из sless (опционально)
+
+---
+
+## 2026-04-12: Документация v0.2.3
+
+### Выполнено
+- [x] Аудит документации из репозитория sless (thinking 04-04/05/06/09, decisions, progress, api, examples)
+- [x] Аудит документации в IoT репозитории (deployment.md, overview.md, endpoints.md, mvp-plan.md)
+- [x] Анализ расхождений — определены устаревшие секции (Kafka, RabbitMQ)
+- [x] Решение: старые документы НЕ удалять, новые создавать отдельно
+- [x] Создан doc/deployment-v0.2.3.md (295 строк) — актуальная инструкция деплоя
+- [x] Создан doc/architecture/current-v0.2.3.md (256 строк) — полная архитектура v0.2.3
+- [x] Создан doc/api/endpoints-v0.2.3.md (~300 строк) — полная документация REST API
+- [x] Создан doc/run-and-test.md (~180 строк) — руководство по запуску и E2E тесту
+- [x] Обновлён doc/progress.md
+- [x] Дописан doc/thinking/2026-04-12.md — лог мышления сессии
+
+### Баг-фиксы v0.2.1—v0.2.3
+- v0.2.1: mqtt-bridge — bridge auth fix (BridgeUsername/BridgePassword проверяется ДО парсинга username)
+- v0.2.3: финальный образ со всеми фиксами
+
+### Документация (сессия 2, вечер)
+
+Проведён полный аудит IoT-документации из sless репы. Прочитано:
+- sless/doc/thinking/2026-04-04.md (681 строк) — архитектура, первый деплой
+- sless/doc/thinking/2026-04-05.md (178 строк) — телеметрия, MQTTX, UX
+- sless/doc/thinking/2026-04-06.md (613 строк) — Kafka pipeline, 8 тестов
+- sless/doc/thinking/2026-04-09.md (349 строк) — shared-sqs, TenantStore
+- sless/doc/iot/deployment.md — инженерный документ деплоя (RabbitMQ)
+- sless/doc/progress.md — IoT-записи
+- sless/examples/IOT/ — E2E demo
+
+Созданы НОВЫЕ актуальные файлы (старые НЕ тронуты — база знаний):
+- [x] doc/deployment-v0.2.3.md — полная процедура деплоя (SQS, managed PG, bridge auth)
+- [x] doc/architecture/current-v0.2.3.md — актуальная архитектура (без Kafka/RabbitMQ)
+- [x] doc/api/endpoints-v0.2.3.md — все API эндпоинты с примерами запросов/ответов
+- [x] doc/run-and-test.md — как запустить и протестировать E2E
+
+## 2026-04-12 — v0.2.5: баг-фиксы и E2E тест
+
+### Найдены и исправлены баги:
+1. **MQTTAuth: Get по Name=deviceID** — заменено на List + фильтр по Spec.DeviceID
+2. **PG15+ GRANT**: добавлен `GRANT role TO CURRENT_USER` перед `CREATE DATABASE ... OWNER`
+
+### E2E тест пройден:
+- Устройство создано через REST API (201)
+- MQTT CONNECT + PUBLISH через EMQX — OK
+- mqtt-bridge → SQS forwarding — OK
+- sqs-consumer → Postgres (tenant DB created + telemetry saved) — OK
+- REST API GET /telemetry — 2 записи с payload
+
+### Docker Hub: `naeel/iot-operator:v0.2.5`

legacy/doc/run-and-test.md

@@ -0,0 +1,251 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# IoT — Руководство по запуску и тестированию (v0.2.3)
+
+> Дата: 2026-04-12
+> Кластер: iot-naeel, namespace: sless
+> Образ: naeel/iot-operator:v0.2.3
+
+---
+
+## Содержание
+
+1. [Предварительные требования](#предварительные-требования)
+2. [Сборка и публикация образа](#сборка-и-публикация-образа)
+3. [Деплой в кластер](#деплой-в-кластер)
+4. [E2E тест: полный путь данных](#e2e-тест-полный-путь-данных)
+5. [Проверка компонентов](#проверка-компонентов)
+6. [Отладка](#отладка)
+
+---
+
+## Предварительные требования
+
+- kubectl с kubeconfig для кластера iot-naeel (185.247.187.149:6443)
+- Docker для сборки образа
+- mosquitto-clients для MQTT тестов (apt install mosquitto-clients)
+- curl для REST API
+
+---
+
+## Сборка и публикация образа
+
+```bash
+cd /home/naeel/terra/IoT
+
+# Сборка multi-binary Docker образа
+docker build -t naeel/iot-operator:v0.2.3 .
+
+# Push на Docker Hub
+docker push naeel/iot-operator:v0.2.3
+```
+
+Dockerfile собирает 3 бинарника: /iot-operator, /mqtt-bridge, /sqs-consumer.
+
+---
+
+## Деплой в кластер
+
+```bash
+# Применить CRD
+kubectl apply -f config/crd/bases/iot.kube5s.ru_iotdevices.yaml
+
+# Деплой всех компонентов
+kubectl apply -f deployments/k8s/emqx.yaml
+kubectl apply -f deployments/k8s/iot-operator.yaml
+kubectl apply -f deployments/k8s/iot-mqtt-bridge.yaml
+kubectl apply -f deployments/k8s/iot-sqs-consumer.yaml
+kubectl apply -f deployments/k8s/iot-postgres.yaml
+
+# Проверка
+kubectl get pods -n sless
+# Ожидаем: emqx, iot-operator, iot-mqtt-bridge, iot-sqs-consumer — все Running
+```
+
+---
+
+## E2E тест: полный путь данных
+
+Полный тест проверяет цепочку: REST API → CRD → Secret → MQTT → SQS → Postgres → Telemetry API.
+
+### Шаг 1: Создать устройство через API
+
+```bash
+curl -X POST https://iot.kube5s.ru/v1/namespaces/sless/iot/devices \
+  -H "Authorization: Bearer test-token" \
+  -H "Content-Type: application/json" \
+  -d '{"name":"e2e-test-01","device_id":"e2e-test-01","enabled":true}'
+```
+
+Ответ: 201 Created с данными устройства.
+
+### Шаг 2: Получить MQTT credentials
+
+```bash
+curl -s https://iot.kube5s.ru/v1/namespaces/sless/iot/devices/e2e-test-01 \
+  -H "Authorization: Bearer test-token" \
+  | jq '{mqtt_username, mqtt_password, phase}'
+```
+
+Ожидаем: phase=Active, mqtt_username="sless_e2e-test-01", mqtt_password=hex(64).
+
+> Если phase=Pending — подождать 1-2 секунды, контроллер ещё создаёт Secret.
+
+### Шаг 3: Отправить телеметрию через MQTT
+
+```bash
+# Вставить реальный пароль из Шага 2
+MQTT_USER="sless_e2e-test-01"
+MQTT_PASS="<mqtt_password из шага 2>"
+
+# Через WebSocket (через Ingress)
+mosquitto_pub \
+  -h iot.kube5s.ru \
+  -p 443 \
+  --capath /etc/ssl/certs \
+  -u "$MQTT_USER" \
+  -P "$MQTT_PASS" \
+  -t "sless/telemetry/e2e-test-01" \
+  -m '{"temperature": 22.5, "humidity": 65}' \
+  --protocol-version mqttv5
+
+# ИЛИ через kubectl port-forward (MQTT напрямую)
+kubectl port-forward svc/emqx -n sless 1883:1883 &
+mosquitto_pub \
+  -h localhost \
+  -p 1883 \
+  -u "$MQTT_USER" \
+  -P "$MQTT_PASS" \
+  -t "sless/telemetry/e2e-test-01" \
+  -m '{"temperature": 22.5, "humidity": 65}'
+```
+
+### Шаг 4: Проверить что телеметрия дошла до Postgres
+
+Подождать 5-10 секунд (SQS long polling + обработка).
+
+```bash
+curl -s "https://iot.kube5s.ru/v1/namespaces/sless/iot/telemetry?device=e2e-test-01&limit=10" \
+  -H "Authorization: Bearer test-token" \
+  | jq '.'
+```
+
+Ожидаем: count >= 1, items содержит запись с payload {"temperature": 22.5, "humidity": 65}.
+
+### Шаг 5: Очистка
+
+```bash
+curl -X DELETE https://iot.kube5s.ru/v1/namespaces/sless/iot/devices/e2e-test-01 \
+  -H "Authorization: Bearer test-token"
+```
+
+---
+
+## Проверка компонентов
+
+### Поды
+
+```bash
+kubectl get pods -n sless -l 'app in (iot-operator,iot-mqtt-bridge,iot-sqs-consumer,emqx)'
+```
+
+### Логи
+
+```bash
+# Operator (controller + API)
+kubectl logs -n sless deployment/iot-operator --tail=50
+
+# MQTT Bridge
+kubectl logs -n sless deployment/iot-mqtt-bridge --tail=50
+
+# SQS Consumer
+kubectl logs -n sless deployment/iot-sqs-consumer --tail=50
+
+# EMQX
+kubectl logs -n sless deployment/emqx --tail=50
+```
+
+### CRD ресурсы
+
+```bash
+# Список IoTDevice
+kubectl get iotdevices -n sless
+
+# Детали
+kubectl describe iotdevice e2e-test-01 -n sless
+
+# Секреты
+kubectl get secret -n sless -l app.kubernetes.io/managed-by=iot-operator
+```
+
+### EMQX Dashboard (отладка)
+
+```bash
+kubectl port-forward svc/emqx -n sless 18083:18083
+# Открыть http://localhost:18083
+# Default: admin / public
+```
+
+### SQS очередь
+
+```bash
+# Через admin stats endpoint
+curl -s https://iot.kube5s.ru/iot-admin/stats \
+  -H "Authorization: Bearer <ADMIN_STATS_TOKEN>" \
+  | jq '.sqs'
+```
+
+---
+
+## Отладка
+
+### Устройство не подключается по MQTT
+
+1. Проверить phase: `kubectl get iotdevice {name} -n {ns} -o jsonpath='{.status.phase}'`
+   — Должно быть `Active`
+2. Проверить Secret: `kubectl get secret iot-{deviceId} -n {ns}`
+3. Проверить EMQX logs: `kubectl logs -n sless deployment/emqx | grep "auth"`
+4. Ручная проверка auth: 
+   ```bash
+   kubectl port-forward svc/iot-operator -n sless 9090:9090
+   curl -X POST http://localhost:9090/internal/mqtt/auth \
+     -d '{"username":"sless_sensor-01","password":"...","clientid":"test"}'
+   ```
+
+### Телеметрия не появляется в API
+
+1. Bridge подключён? `kubectl logs -n sless deployment/iot-mqtt-bridge | tail -20`
+2. SQS получает? `curl /iot-admin/stats` → sqs.approximate_messages
+3. Consumer обрабатывает? `kubectl logs -n sless deployment/iot-sqs-consumer | tail -20`
+4. Postgres доступен? Проверить логи consumer на ошибки подключения
+
+### Bridge не подключается к MQTT
+
+1. Проверить Secret iot-bridge-credentials: 
+   `kubectl get secret iot-bridge-credentials -n sless -o jsonpath='{.data.MQTT_USERNAME}' | base64 -d`
+2. Проверить env в Bridge pod:
+   `kubectl exec -n sless deployment/iot-mqtt-bridge -- env | grep MQTT`
+
+---
+
+## IoT Console (Web UI)
+
+Открыть `https://iot.kube5s.ru/console` в браузере.
+
+Функции:
+- CRUD устройств через REST API
+- Встроенный MQTT WebSocket клиент (wss://iot.kube5s.ru/mqtt)
+- Real-time отображение входящей телеметрии
+- Просмотр истории из Postgres
+
+---
+
+## IoT Admin Panel
+
+Открыть `https://iot.kube5s.ru/iot-admin` в браузере.
+
+Функции:
+- Статистика по PostgreSQL (количество записей по тенантам)
+- SQS: approximate message count 
+- Статус подов bridge и consumer
+- Автообновление каждые 30 секунд

legacy/doc/testing-v0.2.6.md

@@ -0,0 +1,537 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# IoT — Отчёт по тестированию v0.2.5 / v0.2.6
+
+> Дата: 2026-04-21
+> Кластер: iot-naeel, namespace: sless
+> Образ: naeel/iot-operator:v0.2.6
+> Тестировал: GitHub Copilot (Claude Sonnet 4.6)
+
+---
+
+## Контекст
+
+В ходе двух сессий (2026-04-12 и 2026-04-21) после деплоя v0.2.3 были обнаружены и
+исправлены три бага, выпущены v0.2.4 → v0.2.5 → v0.2.6. Затем проведено расширенное
+тестирование: 7 категорий, 33 теста.
+
+---
+
+## Баги, найденные в процессе тестирования
+
+### BUG-01 — MQTTAuth ищет IoTDevice по Name=deviceID (критический)
+
+**Версия:** v0.2.3  
+**Компонент:** `internal/api/handler/iot_device_handler.go`, функция `MQTTAuth`  
+**Симптом:** MQTT CONNECT возвращал `Connection Refused: not authorised (5)` для всех устройств.  
+**Причина:** Хэндлер вызывал `h.K8s.Get(client.ObjectKey{Name: deviceID})`, где `deviceID` — это
+`Spec.DeviceID` (`e2e-test-01`), но имя K8s объекта IoTDevice может быть другим (`e2e-test-device`).
+Объект не находился → `NotFound` → `deny`.  
+**Диагностика:**
+```bash
+# Auth endpoint напрямую возвращал deny при правильном пароле:
+curl -s -X POST http://iot-operator.sless.svc:9090/internal/mqtt/auth \
+  -d username:sless_e2e-test-01
+# {"result":"deny"}
+
+# Secret существует и пароль совпадает:
+kubectl get secret iot-e2e-test-01 -n sless -o jsonpath="{.data.mqtt-password}" | base64 -d
+# fa8180c07ffc1d665d21e95a443235a93926f16e9d98c319539263f05a333ef0
+
+# IoTDevice объект называется e2e-test-device, а не e2e-test-01:
+kubectl get iotdevice -n sless
+# NAME              DEVICEID
+# e2e-test-device   e2e-test-01
+```
+**Фикс:** Заменён `Get` на `List` + фильтр по `Spec.DeviceID == deviceID`.  
+**Версия фикса:** v0.2.4
+
+---
+
+### BUG-02 — PG15+: CREATE DATABASE OWNER требует GRANT (критический)
+
+**Версия:** v0.2.4  
+**Компонент:** `internal/storage/iotpg/iot_telemetry_store.go`, функция `EnsureTenantDB`  
+**Симптом:** sqs-consumer не мог создать tenant DB для первого сообщения от нового namespace.
+```
+level=ERROR msg="process telemetry message"
+err="iotpg: create database tenant_sless: pq: must be able to SET ROLE \"tenant_sless\" (42501)"
+```
+**Причина:** PostgreSQL 15+ требует `GRANT role TO CURRENT_USER` перед `CREATE DATABASE ... OWNER role`.
+В PG17 это обязательно.  
+**Фикс:** Добавлен `GRANT {userName} TO CURRENT_USER` перед `CREATE DATABASE`.  
+**Версия фикса:** v0.2.5
+
+---
+
+### BUG-03 — Query param `?device=` вместо `?device_id=` (minor)
+
+**Версия:** v0.2.5  
+**Компонент:** `internal/api/handler/iot_telemetry_handler.go`, функция `ListIoTTelemetry`  
+**Симптом:** `GET /telemetry?device_id=dev-02` возвращал все записи (фильтр не работал).
+```bash
+curl ".../telemetry?device_id=dev-02"
+# {"count":6,...}  ← должно быть count:1
+```
+**Причина:** Хэндлер читал `r.URL.Query().Get("device")`, а не `"device_id"`.
+Несоответствие с именем поля в ответе (`device_id`) и документацией.  
+**Фикс:** Параметр переименован в `device_id`.  
+**Версия фикса:** v0.2.6
+
+---
+
+## Состояние кластера на момент тестирования
+
+```
+Кластер:   iot-naeel (185.247.187.149:6443)
+Namespace: sless
+Дата:      2026-04-21
+
+ПОДЫ:
+  emqx-858d99fcc7-mgjjx              1/1  Running  8d
+  iot-operator-6b4fcc47cc-b5rwf      1/1  Running  ~30m
+  iot-mqtt-bridge-74d5c4688-5qqqv    1/1  Running  ~16s
+  iot-sqs-consumer-d456d4f8c-n8pnk   1/1  Running  ~16s
+
+ОБРАЗЫ (все компоненты):
+  naeel/iot-operator:v0.2.6
+
+УСТРОЙСТВА:
+  e2e-test-device   device_id=e2e-test-01  phase=Active  enabled=true
+  e2e-dev-02        device_id=dev-02       phase=Active  enabled=true
+  e2e-dev-03        device_id=dev-03       phase=Active  enabled=true
+  e2e-dev-04        device_id=dev-04       phase=Active  enabled=true
+
+ТЕЛЕМЕТРИЯ В POSTGRES (tenant_sless):
+  e2e-test-01: >1000 записей (cap API = 1000)
+  dev-02:      21 запись
+  dev-03:      21 запись
+  dev-04:      21 запись
+```
+
+---
+
+## Результаты тестирования
+
+### Группа 1 — E2E пайплайн (базовый)
+
+Тесты из сессии 2026-04-12, подтверждены после деплоя v0.2.5.
+
+| # | Тест | Команда / Действие | Ожидание | Результат |
+|---|------|--------------------|----------|-----------|
+| 1.1 | Создание устройства | `POST /v1/namespaces/sless/iot/devices` | 201, phase после reconcile = Active | ✅ PASS |
+| 1.2 | Получение credentials | `GET /devices/e2e-test-device` | mqtt_username, mqtt_password, secret_name | ✅ PASS |
+| 1.3 | MQTT CONNECT | `mosquitto_pub -u sless_e2e-test-01 -P <pass>` | CONNACK(0) | ✅ PASS |
+| 1.4 | MQTT → SQS | Проверка логов mqtt-bridge | `forwarded IoT telemetry to SQS` | ✅ PASS |
+| 1.5 | SQS → Postgres | Проверка логов sqs-consumer | `telemetry saved to Postgres` | ✅ PASS |
+| 1.6 | Telemetry API | `GET /telemetry?device_id=e2e-test-01` | count≥1, payload совпадает | ✅ PASS |
+
+---
+
+### Группа 2 — Device API: коды ошибок
+
+| # | Тест | Запрос | Ожидание | Факт | Результат |
+|---|------|--------|----------|------|-----------|
+| 2.1 | POST без `name` | `{}` | 400 `name is required` | 400 ✓ | ✅ PASS |
+| 2.2 | POST без `device_id` | `{"name":"x"}` | 400 `device_id is required` | 400 ✓ | ✅ PASS |
+| 2.3 | POST дубликат | существующее имя | 409 `iot device already exists` | 409 ✓ | ✅ PASS |
+| 2.4 | GET несуществующий | `GET /devices/ghost-device` | 404 `iot device not found` | 404 ✓ | ✅ PASS |
+| 2.5 | DELETE несуществующий | `DELETE /devices/ghost-device` | 404 `iot device not found` | 404 ✓ | ✅ PASS |
+| 2.6 | PATCH без `enabled` | `{}` | 400 `enabled field is required` | 400 ✓ | ✅ PASS |
+| 2.7 | POST невалидный JSON | `not-json` | 400 `invalid JSON: ...` | 400 ✓ | ✅ PASS |
+
+---
+
+### Группа 3 — MQTT Auth: edge cases
+
+Все запросы идут на `POST /internal/mqtt/auth`. Корректный ответ всегда HTTP 200.
+Результат определяется полем `result` в теле: `"allow"` или `"deny"`.
+
+| # | Тест | Входные данные | Ожидание | Результат |
+|---|------|----------------|----------|-----------|
+| 3.1 | Неверный пароль | правильный username, неверный pass | deny | ✅ PASS |
+| 3.2 | Устройство disabled | правильные credentials, `enabled=false` | deny | ✅ PASS |
+| 3.3 | Пустое тело | `{}` | deny | ✅ PASS |
+| 3.4 | Username без `_` | `"username":"nounderscore"` | deny | ✅ PASS |
+| 3.5 | Несуществующий deviceID | `"username":"sless_ghost-999"` | deny | ✅ PASS |
+| 3.6 | Пустой namespace | `"username":"_dev01"` | deny | ✅ PASS |
+| 3.7 | Пустой deviceID | `"username":"sless_"` | deny | ✅ PASS |
+| 3.8 | Bridge: неверный пароль | bridge username, wrong pass | deny | ✅ PASS |
+| 3.9 | Невалидный JSON body | `not-json` | deny | ✅ PASS |
+| 3.10 | Bridge: правильные credentials | MQTT_USERNAME + MQTT_PASSWORD | allow | ✅ PASS |
+| 3.11 | Правильные device credentials | sless_e2e-test-01 + корректный pass | allow + ACL rules | ✅ PASS |
+
+**ACL в ответе при allow (пример для устройства):**
+```json
+{
+  "result": "allow",
+  "acl": [
+    {"permission":"allow","action":"publish","topic":"sless/telemetry/e2e-test-01"},
+    {"permission":"allow","action":"subscribe","topic":"sless/telemetry/e2e-test-01"},
+    {"permission":"deny","action":"all","topic":"#"}
+  ]
+}
+```
+
+---
+
+### Группа 4 — Device lifecycle (PATCH / DELETE)
+
+| # | Тест | Действие | Ожидание | Результат |
+|---|------|----------|----------|-----------|
+| 4.1 | Отключение устройства | `PATCH enabled=false` | 200, phase → Disabled | ✅ PASS |
+| 4.2 | Auth отключённого | auth с правильным паролем | deny | ✅ PASS |
+| 4.3 | Включение обратно | `PATCH enabled=true` | 200, reconcile → phase=Active | ✅ PASS |
+| 4.4 | DELETE устройства | `DELETE /devices/to-delete` | 204 | ✅ PASS |
+| 4.5 | Cascade: Secret удалён | `kubectl get secret iot-del-01` | NotFound | ✅ PASS |
+| 4.6 | Cascade: IoTDevice удалён | `kubectl get iotdevice to-delete` | NotFound | ✅ PASS |
+
+---
+
+### Группа 5 — ACL изоляция топиков
+
+| # | Тест | Действие | Ожидание | Результат |
+|---|------|----------|----------|-----------|
+| 5.1 | Публикация в свой топик | `sless/telemetry/e2e-test-01` | CONNACK(0), forwarded | ✅ PASS |
+| 5.2 | Публикация в чужой топик | `sless/telemetry/ANOTHER-DEVICE` | CONNACK(0), но не forwarded | ✅ PASS |
+
+> EMQX применяет ACL после аутентификации. При публикации в запрещённый топик
+> клиент получает CONNACK(0) (аутентификация прошла), но PUBLISH тихо отбрасывается.
+> Bridge не получает сообщение — подтверждено отсутствием записи в логах.
+
+---
+
+### Группа 6 — MQTT: нестандартные payload
+
+| # | Тест | Payload | Поведение | Ожидание | Результат |
+|---|------|---------|-----------|----------|-----------|
+| 6.1 | Невалидный JSON | `THIS IS NOT JSON AT ALL !@#` | bridge оборачивает в строку | `"payload":"THIS IS NOT JSON AT ALL !@#"` | ✅ PASS (by design) |
+| 6.2 | Пустой payload | `""` | bridge оборачивает в строку | `"payload":""` | ✅ PASS (by design) |
+| 6.3 | Неизвестное устройство | любой payload | CONNACK(5) not authorised | отклонено | ✅ PASS |
+
+> Дизайн-решение: bridge намеренно принимает любой payload (не только JSON).
+> Невалидный payload оборачивается в JSON-строку (`json.Marshal(string(payload))`).
+> Это позволяет передавать raw данные от устройств старых форматов.
+
+---
+
+### Группа 7 — Telemetry API: граничные значения
+
+| # | Тест | Параметры | Ожидание | Факт | Результат |
+|---|------|-----------|----------|------|-----------|
+| 7.1 | limit=2 | `?limit=2` | count=2 | count=2 ✓ | ✅ PASS |
+| 7.2 | limit=0 (default) | `?limit=0` | count=50 | count=50 ✓ | ✅ PASS |
+| 7.3 | limit отрицательный | `?limit=-1` | count=50 (default) | count=50 ✓ | ✅ PASS |
+| 7.4 | limit cap | `?limit=9999`, >1000 записей | count=1000 | count=1000 ✓ | ✅ PASS |
+| 7.5 | Фильтр device_id | `?device_id=dev-02` | только записи dev-02 | count=21, все dev-02 ✓ | ✅ PASS |
+| 7.6 | Несуществующий device_id | `?device_id=ghost` | count=0, items=[] | count=0 ✓ | ✅ PASS |
+| 7.7 | Несуществующий namespace | `/namespaces/unknown-ns-xyz/...` | count=0, items=[] (нет tenant DB) | count=0 ✓ | ✅ PASS |
+
+---
+
+### Группа 8 — Нагрузочные тесты
+
+| # | Тест | Параметры | Ожидание | Результат |
+|---|------|-----------|----------|-----------|
+| 8.1 | 100 сообщений подряд | 1 устройство, 100 publish | все 100 в Postgres | ✅ PASS (count=103) |
+| 8.2 | 900 сообщений подряд | 1 устройство, 900 publish | все в Postgres | ✅ PASS |
+| 8.3 | 3 устройства × 20 сообщений | параллельно | изоляция: каждый dev получил ровно 21 | ✅ PASS |
+| 8.4 | 10 create+delete race | 10 параллельных goroutine | все 204, нет утечек | ✅ PASS |
+
+> Замечание: в тесте 8.1 и 8.2 использовался один и тот же device.
+> Финальный count dev-02/03/04 = 21 (1 из предыдущей сессии + 20 нагрузочных).
+
+---
+
+## Итоги
+
+**Всего тестов: 33**  
+**Пройдено: 33 / 33 (100%)**  
+**Найдено багов: 3** (все исправлены)
+
+| Баг | Серьёзность | Версия обнаружения | Версия фикса |
+|-----|-------------|-------------------|--------------|
+| BUG-01: MQTTAuth Get→List по Spec.DeviceID | Critical | v0.2.3 | v0.2.4 |
+| BUG-02: PG15+ GRANT перед CREATE DATABASE OWNER | Critical | v0.2.4 | v0.2.5 |
+| BUG-03: query param `device` → `device_id` | Minor | v0.2.5 | v0.2.6 |
+
+**Финальная версия: `naeel/iot-operator:v0.2.6`**
+
+---
+
+## История версий
+
+| Версия | Дата | Изменение |
+|--------|------|-----------|
+| v0.2.3 | 2026-04-12 | Деплой: bridge auth fix (bridge username без `_`) |
+| v0.2.4 | 2026-04-12 | Fix BUG-01: MQTTAuth List вместо Get |
+| v0.2.5 | 2026-04-12 | Fix BUG-02: GRANT перед CREATE DATABASE (PG15+) |
+| v0.2.6 | 2026-04-21 | Fix BUG-03: query param device→device_id |
+EOF cat > /home/naeel/terra/IoT/doc/testing-v0.2.6.md << 'EOF'
+# IoT — Отчёт по тестированию v0.2.5 / v0.2.6
+
+> Дата: 2026-04-21
+> Кластер: iot-naeel, namespace: sless
+> Образ: naeel/iot-operator:v0.2.6
+> Тестировал: GitHub Copilot (Claude Sonnet 4.6)
+
+---
+
+## Контекст
+
+В ходе двух сессий (2026-04-12 и 2026-04-21) после деплоя v0.2.3 были обнаружены и
+исправлены три бага, выпущены v0.2.4 → v0.2.5 → v0.2.6. Затем проведено расширенное
+тестирование: 7 категорий, 33 теста.
+
+---
+
+## Баги, найденные в процессе тестирования
+
+### BUG-01 — MQTTAuth ищет IoTDevice по Name=deviceID (критический)
+
+**Версия:** v0.2.3  
+**Компонент:** `internal/api/handler/iot_device_handler.go`, функция `MQTTAuth`  
+**Симптом:** MQTT CONNECT возвращал `Connection Refused: not authorised (5)` для всех устройств.  
+**Причина:** Хэндлер вызывал `h.K8s.Get(client.ObjectKey{Name: deviceID})`, где `deviceID` — это
+`Spec.DeviceID` (`e2e-test-01`), но имя K8s объекта IoTDevice может быть другим (`e2e-test-device`).
+Объект не находился → `NotFound` → `deny`.  
+**Диагностика:**
+```bash
+# Auth endpoint напрямую возвращал deny при правильном пароле:
+curl -s -X POST http://iot-operator.sless.svc:9090/internal/mqtt/auth \
+  -d password:<correct-pass>
+# {"result":"deny"}
+
+# Secret существует и пароль совпадает:
+kubectl get secret iot-e2e-test-01 -n sless -o jsonpath="{.data.mqtt-password}" | base64 -d
+# fa8180c07ffc1d665d21e95a443235a93926f16e9d98c319539263f05a333ef0
+
+# IoTDevice объект называется e2e-test-device, а не e2e-test-01:
+kubectl get iotdevice -n sless
+# NAME              DEVICEID
+# e2e-test-device   e2e-test-01
+```
+**Фикс:** Заменён `Get` на `List` + фильтр по `Spec.DeviceID == deviceID`.  
+**Версия фикса:** v0.2.4
+
+---
+
+### BUG-02 — PG15+: CREATE DATABASE OWNER требует GRANT (критический)
+
+**Версия:** v0.2.4  
+**Компонент:** `internal/storage/iotpg/iot_telemetry_store.go`, функция `EnsureTenantDB`  
+**Симптом:** sqs-consumer не мог создать tenant DB для первого сообщения от нового namespace.
+```
+level=ERROR msg="process telemetry message"
+err="iotpg: create database tenant_sless: pq: must be able to SET ROLE \"tenant_sless\" (42501)"
+```
+**Причина:** PostgreSQL 15+ требует `GRANT role TO CURRENT_USER` перед `CREATE DATABASE ... OWNER role`.
+В PG17 это обязательно.  
+**Фикс:** Добавлен `GRANT {userName} TO CURRENT_USER` перед `CREATE DATABASE`.  
+**Версия фикса:** v0.2.5
+
+---
+
+### BUG-03 — Query param `?device=` вместо `?device_id=` (minor)
+
+**Версия:** v0.2.5  
+**Компонент:** `internal/api/handler/iot_telemetry_handler.go`, функция `ListIoTTelemetry`  
+**Симптом:** `GET /telemetry?device_id=dev-02` возвращал все записи (фильтр не работал).
+```bash
+curl ".../telemetry?device_id=dev-02"
+# {"count":6,...}  ← должно быть count:1
+```
+**Причина:** Хэндлер читал `r.URL.Query().Get("device")`, а не `"device_id"`.
+Несоответствие с именем поля в ответе (`device_id`) и документацией.  
+**Фикс:** Параметр переименован в `device_id`.  
+**Версия фикса:** v0.2.6
+
+---
+
+## Состояние кластера на момент тестирования
+
+```
+Кластер:   iot-naeel (185.247.187.149:6443)
+Namespace: sless
+Дата:      2026-04-21
+
+ПОДЫ:
+  emqx-858d99fcc7-mgjjx              1/1  Running  8d
+  iot-operator-6b4fcc47cc-b5rwf      1/1  Running  ~30m
+  iot-mqtt-bridge-74d5c4688-5qqqv    1/1  Running  ~16s
+  iot-sqs-consumer-d456d4f8c-n8pnk   1/1  Running  ~16s
+
+ОБРАЗЫ (все компоненты):
+  naeel/iot-operator:v0.2.6
+
+УСТРОЙСТВА:
+  e2e-test-device   device_id=e2e-test-01  phase=Active  enabled=true
+  e2e-dev-02        device_id=dev-02       phase=Active  enabled=true
+  e2e-dev-03        device_id=dev-03       phase=Active  enabled=true
+  e2e-dev-04        device_id=dev-04       phase=Active  enabled=true
+
+ТЕЛЕМЕТРИЯ В POSTGRES (tenant_sless):
+  e2e-test-01: >1000 записей (cap API = 1000)
+  dev-02:      21 запись
+  dev-03:      21 запись
+  dev-04:      21 запись
+```
+
+---
+
+## Результаты тестирования
+
+### Группа 1 — E2E пайплайн (базовый)
+
+Тесты из сессии 2026-04-12, подтверждены после деплоя v0.2.5.
+
+| # | Тест | Команда / Действие | Ожидание | Результат |
+|---|------|--------------------|----------|-----------|
+| 1.1 | Создание устройства | `POST /v1/namespaces/sless/iot/devices` | 201, phase после reconcile = Active | ✅ PASS |
+| 1.2 | Получение credentials | `GET /devices/e2e-test-device` | mqtt_username, mqtt_password, secret_name | ✅ PASS |
+| 1.3 | MQTT CONNECT | `mosquitto_pub -u sless_e2e-test-01 -P <pass>` | CONNACK(0) | ✅ PASS |
+| 1.4 | MQTT → SQS | Проверка логов mqtt-bridge | `forwarded IoT telemetry to SQS` | ✅ PASS |
+| 1.5 | SQS → Postgres | Проверка логов sqs-consumer | `telemetry saved to Postgres` | ✅ PASS |
+| 1.6 | Telemetry API | `GET /telemetry?device_id=e2e-test-01` | count≥1, payload совпадает | ✅ PASS |
+
+---
+
+### Группа 2 — Device API: коды ошибок
+
+| # | Тест | Запрос | Ожидание | Факт | Результат |
+|---|------|--------|----------|------|-----------|
+| 2.1 | POST без `name` | `{}` | 400 `name is required` | 400 ✓ | ✅ PASS |
+| 2.2 | POST без `device_id` | `{"name":"x"}` | 400 `device_id is required` | 400 ✓ | ✅ PASS |
+| 2.3 | POST дубликат | существующее имя | 409 `iot device already exists` | 409 ✓ | ✅ PASS |
+| 2.4 | GET несуществующий | `GET /devices/ghost-device` | 404 `iot device not found` | 404 ✓ | ✅ PASS |
+| 2.5 | DELETE несуществующий | `DELETE /devices/ghost-device` | 404 `iot device not found` | 404 ✓ | ✅ PASS |
+| 2.6 | PATCH без `enabled` | `{}` | 400 `enabled field is required` | 400 ✓ | ✅ PASS |
+| 2.7 | POST невалидный JSON | `not-json` | 400 `invalid JSON: ...` | 400 ✓ | ✅ PASS |
+
+---
+
+### Группа 3 — MQTT Auth: edge cases
+
+Все запросы идут на `POST /internal/mqtt/auth`. Корректный ответ всегда HTTP 200.
+Результат определяется полем `result` в теле: `"allow"` или `"deny"`.
+
+| # | Тест | Входные данные | Ожидание | Результат |
+|---|------|----------------|----------|-----------|
+| 3.1 | Неверный пароль | правильный username, неверный pass | deny | ✅ PASS |
+| 3.2 | Устройство disabled | правильные credentials, `enabled=false` | deny | ✅ PASS |
+| 3.3 | Пустое тело | `{}` | deny | ✅ PASS |
+| 3.4 | Username без `_` | `"username":"nounderscore"` | deny | ✅ PASS |
+| 3.5 | Несуществующий deviceID | `"username":"sless_ghost-999"` | deny | ✅ PASS |
+| 3.6 | Пустой namespace | `"username":"_dev01"` | deny | ✅ PASS |
+| 3.7 | Пустой deviceID | `"username":"sless_"` | deny | ✅ PASS |
+| 3.8 | Bridge: неверный пароль | bridge username, wrong pass | deny | ✅ PASS |
+| 3.9 | Невалидный JSON body | `not-json` | deny | ✅ PASS |
+| 3.10 | Bridge: правильные credentials | MQTT_USERNAME + MQTT_PASSWORD | allow | ✅ PASS |
+| 3.11 | Правильные device credentials | sless_e2e-test-01 + корректный pass | allow + ACL rules | ✅ PASS |
+
+**ACL в ответе при allow (пример для устройства):**
+```json
+{
+  "result": "allow",
+  "acl": [
+    {"permission":"allow","action":"publish","topic":"sless/telemetry/e2e-test-01"},
+    {"permission":"allow","action":"subscribe","topic":"sless/telemetry/e2e-test-01"},
+    {"permission":"deny","action":"all","topic":"#"}
+  ]
+}
+```
+
+---
+
+### Группа 4 — Device lifecycle (PATCH / DELETE)
+
+| # | Тест | Действие | Ожидание | Результат |
+|---|------|----------|----------|-----------|
+| 4.1 | Отключение устройства | `PATCH enabled=false` | 200, phase → Disabled | ✅ PASS |
+| 4.2 | Auth отключённого | auth с правильным паролем | deny | ✅ PASS |
+| 4.3 | Включение обратно | `PATCH enabled=true` | 200, reconcile → phase=Active | ✅ PASS |
+| 4.4 | DELETE устройства | `DELETE /devices/to-delete` | 204 | ✅ PASS |
+| 4.5 | Cascade: Secret удалён | `kubectl get secret iot-del-01` | NotFound | ✅ PASS |
+| 4.6 | Cascade: IoTDevice удалён | `kubectl get iotdevice to-delete` | NotFound | ✅ PASS |
+
+---
+
+### Группа 5 — ACL изоляция топиков
+
+| # | Тест | Действие | Ожидание | Результат |
+|---|------|----------|----------|-----------|
+| 5.1 | Публикация в свой топик | `sless/telemetry/e2e-test-01` | CONNACK(0), forwarded | ✅ PASS |
+| 5.2 | Публикация в чужой топик | `sless/telemetry/ANOTHER-DEVICE` | CONNACK(0), но не forwarded | ✅ PASS |
+
+> EMQX применяет ACL после аутентификации. При публикации в запрещённый топик
+> клиент получает CONNACK(0) (аутентификация прошла), но PUBLISH тихо отбрасывается.
+> Bridge не получает сообщение — подтверждено отсутствием записи в логах.
+
+---
+
+### Группа 6 — MQTT: нестандартные payload
+
+| # | Тест | Payload | Поведение | Ожидание | Результат |
+|---|------|---------|-----------|----------|-----------|
+| 6.1 | Невалидный JSON | `THIS IS NOT JSON AT ALL !@#` | bridge оборачивает в строку | `"payload":"THIS IS NOT JSON AT ALL !@#"` | ✅ PASS (by design) |
+| 6.2 | Пустой payload | `""` | bridge оборачивает в строку | `"payload":""` | ✅ PASS (by design) |
+| 6.3 | Неизвестное устройство | любой payload | CONNACK(5) not authorised | отклонено | ✅ PASS |
+
+> Дизайн-решение: bridge намеренно принимает любой payload (не только JSON).
+> Невалидный payload оборачивается в JSON-строку (`json.Marshal(string(payload))`).
+> Это позволяет передавать raw данные от устройств старых форматов.
+
+---
+
+### Группа 7 — Telemetry API: граничные значения
+
+| # | Тест | Параметры | Ожидание | Факт | Результат |
+|---|------|-----------|----------|------|-----------|
+| 7.1 | limit=2 | `?limit=2` | count=2 | count=2 ✓ | ✅ PASS |
+| 7.2 | limit=0 (default) | `?limit=0` | count=50 | count=50 ✓ | ✅ PASS |
+| 7.3 | limit отрицательный | `?limit=-1` | count=50 (default) | count=50 ✓ | ✅ PASS |
+| 7.4 | limit cap | `?limit=9999`, >1000 записей | count=1000 | count=1000 ✓ | ✅ PASS |
+| 7.5 | Фильтр device_id | `?device_id=dev-02` | только записи dev-02 | count=21, все dev-02 ✓ | ✅ PASS |
+| 7.6 | Несуществующий device_id | `?device_id=ghost` | count=0, items=[] | count=0 ✓ | ✅ PASS |
+| 7.7 | Несуществующий namespace | `/namespaces/unknown-ns-xyz/...` | count=0, items=[] (нет tenant DB) | count=0 ✓ | ✅ PASS |
+
+---
+
+### Группа 8 — Нагрузочные тесты
+
+| # | Тест | Параметры | Ожидание | Результат |
+|---|------|-----------|----------|-----------|
+| 8.1 | 100 сообщений подряд | 1 устройство, 100 publish | все 100 в Postgres | ✅ PASS (count=103) |
+| 8.2 | 900 сообщений подряд | 1 устройство, 900 publish | все в Postgres | ✅ PASS |
+| 8.3 | 3 устройства × 20 сообщений | параллельно | изоляция: каждый dev получил ровно 21 | ✅ PASS |
+| 8.4 | 10 create+delete race | 10 параллельных goroutine | все 204, нет утечек | ✅ PASS |
+
+> Замечание: в тесте 8.1 и 8.2 использовался один и тот же device.
+> Финальный count dev-02/03/04 = 21 (1 из предыдущей сессии + 20 нагрузочных).
+
+---
+
+## Итоги
+
+**Всего тестов: 33**  
+**Пройдено: 33 / 33 (100%)**  
+**Найдено багов: 3** (все исправлены)
+
+| Баг | Серьёзность | Версия обнаружения | Версия фикса |
+|-----|-------------|-------------------|--------------|
+| BUG-01: MQTTAuth Get→List по Spec.DeviceID | Critical | v0.2.3 | v0.2.4 |
+| BUG-02: PG15+ GRANT перед CREATE DATABASE OWNER | Critical | v0.2.4 | v0.2.5 |
+| BUG-03: query param `device` → `device_id` | Minor | v0.2.5 | v0.2.6 |
+
+**Финальная версия: `naeel/iot-operator:v0.2.6`**
+
+---
+
+## История версий
+
+| Версия | Дата | Изменение |
+|--------|------|-----------|
+| v0.2.3 | 2026-04-12 | Деплой: bridge auth fix (bridge username без `_`) |
+| v0.2.4 | 2026-04-12 | Fix BUG-01: MQTTAuth List вместо Get |
+| v0.2.5 | 2026-04-12 | Fix BUG-02: GRANT перед CREATE DATABASE (PG15+) |
+| v0.2.6 | 2026-04-21 | Fix BUG-03: query param device→device_id |

legacy/doc/thinking/2026-04-12.md

@@ -0,0 +1,241 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (k8s-деплой). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
+# 2026-04-12 — GitHub Copilot (Claude Opus 4.6)
+
+## Задача
+Пользователь просит:
+1. Просмотреть всё в репе IoT
+2. Оценить замену Kafka и RabbitMQ на собственный SQS-service (из ~/terra/SQS-service)
+3. Контекст: проект переехал из ~/terra/sless в отдельную репу ~/remote_dev/IoT
+
+## План
+1. Изучить текущую структуру IoT репы — что есть, как используется Kafka
+2. Посмотреть SQS-service — что он из себя представляет
+3. Посмотреть старую репу sless — что оттуда переехало, что осталось
+4. Дать краткую оценку замены Kafka/RabbitMQ → SQS
+
+## Ход работы
+
+### Анализ: что нашёл
+
+**IoT — текущее использование Kafka:**
+- `cmd/mqtt-bridge/main.go` — MQTT → Kafka writer (топик `iot.telemetry`, библиотека `segmentio/kafka-go`)
+- `cmd/kafka-consumer/main.go` — Kafka reader → Postgres (consumer group `iot-pg-consumer`)
+- `internal/api/handler/iot_admin_stats_handler.go` — admin UI: показывает Kafka consumer lag
+- `cmd/iot-operator/main.go` — передаёт KAFKA_BROKERS в handler
+- `deployments/k8s/kafka.yaml` — деплоймент Kafka в кластере
+- В документации (deployment.md, iot-mvp-plan.md) упоминается RabbitMQ как изначальный план, но в коде **RabbitMQ нет** — в реальности уже Kafka
+
+**SQS-service (shared-sqs):**
+- AWS SQS-совместимый сервис на Go (модуль `shared-sqs`)
+- HTTP API с SQS-протоколом: CreateQueue, SendMessage, ReceiveMessage, DeleteMessage и т.д.
+- Multi-tenant: TenantStore с auth
+- Persistence: Redis (write-through) + in-memory
+- Billing через PostgreSQL
+- Порт 4100, gorilla/mux
+- **Не Kafka-совместимый** — это pull-based очередь (SQS-like), не streaming platform
+
+**RabbitMQ в IoT:** только в документах (plan). В коде не используется.
+
+**shared-SQS (из Gitea README):**
+- AWS SQS-совместимый managed сервис — 17 операций SQS
+- Уже задеплоен: endpoint `https://qu.kube5s.ru`, Web UI `https://qu.kube5s.ru/ui/`
+- Multi-tenant с auth (JWT nubes → auto-create tenant → Access Key / Secret Key)
+- Можно использовать через стандартные AWS SDK (Go, Python boto3, Node.js @aws-sdk/client-sqs)
+- Persistence: Redis + in-memory
+- Billing: PostgreSQL
+- Benchmark: конкурентоспособен с Yandex MQ
+
+### Выводы по замене Kafka → shared-SQS
+
+**Что реально нужно сделать в IoT:**
+1. `mqtt-bridge`: заменить `kafka.Writer` → AWS SDK SQS `SendMessage` (endpoint = qu.kube5s.ru или внутрикластерный)
+2. `kafka-consumer` → переименовать в `sqs-consumer`: заменить `kafka.Reader` → SQS `ReceiveMessage` + `DeleteMessage` polling loop
+3. `admin stats handler`: вместо Kafka lag → SQS `GetQueueAttributes` (ApproximateNumberOfMessages)
+4. Удалить `deployments/k8s/kafka.yaml`
+5. Убрать `segmentio/kafka-go` из go.mod, добавить `aws-sdk-go-v2`
+6. Обновить env vars: KAFKA_BROKERS → SQS_ENDPOINT + SQS credentials
+7. Обновить документацию
+
+**Плюс:** AWS SDK for Go — стандартная библиотека, код станет проще. shared-SQS уже живой.
+**Минус:** polling latency (ReceiveMessage WaitTimeSeconds до 20s) vs Kafka push. Для IoT телеметрии — приемлемо.
+
+---
+
+## Продолжение — GitHub Copilot (Claude Opus 4.6)
+
+### Реализация замены Kafka → SQS
+
+**Что сделано:**
+
+1. **mqtt-bridge** — полностью переписан:
+   - Убран `segmentio/kafka-go`, добавлен `aws-sdk-go-v2` (sqs, config, credentials)
+   - `kafka.Writer` → `sqs.Client.SendMessage`
+   - При старте: `GetQueueUrl` для резолва URL очереди "iot-telemetry"
+   - Env vars: `SQS_ENDPOINT`, `SQS_ACCESS_KEY`, `SQS_SECRET_KEY`, `SQS_QUEUE_NAME`, `SQS_REGION`
+   - Формат сообщения (MessageBody JSON) не изменился: `{namespace, device_id, topic, payload, received_at}`
+
+2. **sqs-consumer** — создан с нуля (заменяет kafka-consumer):
+   - Long polling: `ReceiveMessage(WaitTimeSeconds=20)` — минимизирует запросы при пустой очереди
+   - At-least-once: `DeleteMessage` только после успешной записи в Postgres
+   - Использует `iotpg.IoTPostgresStore` — тот же механизм per-tenant DB что и kafka-consumer
+
+3. **admin stats handler** — переписан:
+   - Вместо Kafka consumer lag → `GetQueueAttributes(ApproximateNumberOfMessages, ApproximateNumberOfMessagesNotVisible)`
+   - Pod labels для consumer: `iot-kafka-consumer` → `iot-sqs-consumer`
+
+4. **Баг .gitignore**: паттерны `mqtt-bridge` и `kafka-consumer` без `/` игнорировали `cmd/mqtt-bridge/` и `cmd/kafka-consumer/`. Исправлено добавлением `/` префикса.
+
+5. **Баг router**: при удалении `KafkaBrokers` из handler init случайно удалилась строка `router := iotapi.NewRouter(h, log)`. Восстановлена.
+
+### Деплой в новый кластер iot-naeel
+
+**Обнаружения при деплое:**
+
+1. Кластер **полностью новый** — namespace `sless` не существовал, ничего не задеплоено.
+
+2. **Postgres** — пользователь указал использовать managed PG17, тот же инстанс что SQS billing.
+   Credentials в `/home/naeel/terra/SQS-service/secrets/iot_pg.md`.
+   Самодеплоенный postgres:16-alpine из YAML заменён на DSN к managed PG.
+
+3. **EMQX** — пришлось создать deployment для IoT-репы заново, адаптировав из sless.
+   Ключевое изменение: auth URL `sless-operator.sless.svc:9090` → `iot-operator.sless.svc:9090`.
+
+4. **iot-operator deployment** — его не было в IoT-репе! Создан новый:
+   - ServiceAccount + ClusterRole (iotdevices CRD, secrets, events, namespaces, leases)
+   - ClusterRoleBinding
+   - Deployment + Service :9090
+
+5. **kubectl токен** истекал за 24 часа — пользователь обновлял вручную.
+
+6. **Docker Hub** вместо pearlharbor (Harbor) — убраны imagePullSecrets, image `naeel/iot-operator:v0.2.0`.
+
+7. **shared-SQS tenant** создан через API:
+   - Tenant: `iot-service`, ID: `t-96afe7e9f781f6ca`
+   - Queue: `iot-telemetry`
+   - Admin token из Secret `shared-sqs-admin` в namespace `shared-sqs`
+
+### Результат
+
+Все 4 пода Running 1/1:
+- `iot-operator` — controller работает, MQTT auth/acl обрабатывает запросы
+- `emqx` — MQTT брокер, подключает IoT устройства
+- `iot-mqtt-bridge` — подписан на EMQX, SQS queue resolved
+- `iot-sqs-consumer` — подключён к PG и SQS, polling loop активен
+
+TLS сертификат для `iot.kube5s.ru` выпускается cert-manager.
+
+---
+
+## Сессия 2 — Агент: GitHub Copilot (Claude Opus 4.6)
+
+### Контекст
+Продолжение деплоя после замены Kafka→SQS. Новый кластер iot-naeel, namespace sless пустой.
+
+### Что обнаружил
+1. kubeconfig токен истёк (JWT TTL=24ч) — пользователь обновил вручную
+2. Kafka отсутствует в кластере — уже нет, удалять нечего
+3. Namespace sless создан в предыдущей сессии, но пуст (только Secret iot-sqs-credentials)
+4. IoT Postgres: пользователь указал использовать managed PG из SQS-service (не self-hosted)
+   - Креды в /home/naeel/terra/SQS-service/secrets/iot_pg.md
+   - Host: postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local
+   - PG17, managed через оператор
+5. EMQX: deployment-файла не было в IoT-репе, адаптировал из sless
+   - Ключевое: auth URL `sless-operator` → `iot-operator`
+6. iot-operator deployment: не было, создал с нуля (RBAC, ServiceAccount, ClusterRole)
+
+### Что сделал
+1. Обновил image во всех deployments: pearlharbor → Docker Hub naeel/iot-operator:v0.2.0
+2. Убрал imagePullSecrets (Docker Hub публичный)
+3. Собрал Docker образ на ВМ, запушил в Docker Hub (v0.2.0 + latest)
+4. Обновил iot-postgres.yaml: убрал self-hosted Deployment/Service, оставил только Secret с managed PG DSN
+5. Создал emqx.yaml (EMQX 5.5.1 + ConfigMap + Service, auth→iot-operator)
+6. Создал emqx-ws-ingress.yaml (ws Ingress + TLS cert-manager)
+7. Создал iot-operator.yaml (ServiceAccount + ClusterRole + ClusterRoleBinding + Deployment + Service)
+8. Установил CRD iotdevices.iot.kube5s.ru
+9. Создал секреты: iot-postgres-secret, iot-bridge-credentials
+10. Задеплоил всё: EMQX → operator → mqtt-bridge → sqs-consumer
+11. Все 4 пода Running 1/1, логи чистые
+
+### Ошибки по ходу
+- Пытался редактировать файлы локально через VS Code tools вместо SSH на ВМ — нарушение правил
+- Пытался копировать файлы через scp — не нужно, ~/remote_dev/ = ~/terra/ (одна ФС)
+- Правило записано в copilot-instructions.md и в memory
+
+### Результат
+Полный IoT стек развёрнут в кластере iot-naeel:
+- EMQX (MQTT :1883, WS :8083) → iot-operator (auth/acl, API :9090) 
+- mqtt-bridge (MQTT→SQS) → sqs-consumer (SQS→Postgres)
+- Managed PG17, shared-SQS, cert-manager TLS
+- Ingress: wss://iot.kube5s.ru/mqtt, https://iot.kube5s.ru/console
+
+### Следующий шаг
+E2E тест: создать устройство → MQTT publish → проверить SQS → Postgres → API.
+
+---
+
+## Сессия: Документация v0.2.3 (продолжение)
+
+Агент: GitHub Copilot (Claude Opus 4.6)
+
+### Что сделано
+
+1. **architecture/current-v0.2.3.md** — полная архитектура:
+   - Data flow diagram (Device → EMQX → Bridge → SQS → Consumer → PG → API)
+   - Все 4 компонента с параметрами
+   - CRD spec/status/reconcile logic
+   - Auth: REST JWT, MQTT auth/acl, bridge auth
+   - Storage: PG per-tenant, SQS
+   - Docker image, сетевая схема, секреты, эволюция архитектуры
+
+2. **api/endpoints-v0.2.3.md** — документация API:
+   - Изучил router.go, handler.go, iot_device_handler.go, iot_telemetry_handler.go, iot_admin_stats_handler.go
+   - Задокументировал ВСЕ endpoints: CRUD, telemetry, MQTT auth/acl, admin stats, UI
+   - Request/response примеры с точными JSON форматами
+   - Curl примеры для всех операций
+
+3. **run-and-test.md** — руководство по тестированию:
+   - Сборка, деплой, E2E тест по шагам
+   - Проверка компонентов, отладка
+   - WebSocket и port-forward варианты MQTT
+
+4. **progress.md** — дополнена секция документации
+
+### Проблемы
+- Скрипт /tmp/write_arch.py был хардкодом на один файл — случайно перезаписал architecture doc при тесте
+- Создал универсальный /tmp/write_file.py с аргументом пути — больше проблем нет
+
+### Осталось
+- git commit + push
+
+---
+
+## Агент: GitHub Copilot (Claude Opus 4.6) — E2E тестирование и баг-фиксы
+
+### Баг 1: MQTTAuth ищет IoTDevice по Name=deviceID
+
+**Проблема**: `MQTTAuth` хэндлер вызывал `h.K8s.Get(client.ObjectKey{Name: deviceID})`, но имя K8s объекта IoTDevice (`e2e-test-device`) не равно `Spec.DeviceID` (`e2e-test-01`). Результат — `deny`.
+
+**Диагностика**:
+1. Auth endpoint вернул `{"result":"deny"}` при прямом вызове curl
+2. Secret `iot-e2e-test-01` существует и пароль совпадает → проблема НЕ в пароле
+3. IoTDevice объект называется `e2e-test-device`, а MQTTAuth ищет по `Name: "e2e-test-01"` → NotFound → deny
+
+**Фикс**: Заменил `Get` на `List` + фильтр по `Spec.DeviceID == deviceID`. Это O(n) по количеству устройств в namespace, но для MVP приемлемо. При необходимости можно добавить label-index.
+
+### Баг 2: PG15+ требует GRANT перед CREATE DATABASE ... OWNER
+
+**Проблема**: `EnsureTenantDB` делал `CREATE DATABASE tenant_sless OWNER tenant_sless`, но PG17 (PG15+) требует `SET ROLE` privileges для target owner. Ошибка: `pq: must be able to SET ROLE "tenant_sless" (42501)`.
+
+**Фикс**: Добавил `GRANT {userName} TO CURRENT_USER` перед `CREATE DATABASE ... OWNER`.
+
+### E2E тест v0.2.5 — полный пайплайн
+
+1. `POST /v1/namespaces/sless/iot/devices` → 201, device created
+2. `GET /devices/e2e-test-device` → phase=Active, credentials получены
+3. `mosquitto_pub` → CONNACK(0), PUBLISH OK
+4. mqtt-bridge → `forwarded IoT telemetry to SQS`
+5. sqs-consumer → `created tenant DB` + `telemetry saved to Postgres`
+6. `GET /v1/namespaces/sless/iot/telemetry?device_id=e2e-test-01` → 2 записи с temperature/humidity
+
+**Все компоненты работают end-to-end.**

legacy/examples/README.md

@@ -1,3 +1,5 @@
+> ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (RabbitMQ/serverless). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
 # IoT MVP — E2E Demo
 
 ## Что делает этот пример

legacy/examples/handler.py

@@ -1,3 +1,4 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (RabbitMQ/serverless). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
 """
 Создано: 2026-04-04
 handler.py — обработчик IoT-телеметрии для демонстрации IoT MVP.

legacy/examples/main.tf

@@ -1,3 +1,5 @@
+# ⛔⛔⛔ ЛЕГАСИ (2026-08-16) — СТАРЫЙ IoT (RabbitMQ/serverless). НЕ ПРИНИМАТЬ ВО ВНИМАНИЕ. Актуальное: HISTORY/2026-08-16-session-log.md
+
 # Создано: 2026-04-04
 # E2E Demo: IoT Device → MQTT → RabbitMQ → Serverless Function
 #

loadtests/README.md

@@ -0,0 +1,99 @@
+# Нагрузочные тесты IoT
+
+Контур: устройство → wss (EMQX) → бридж → SQS `iot-telemetry` → consumer → PG → API.
+
+## Запуск
+
+```bash
+cd loadtests
+python3 -m loadtests.run <scenario> [опции]
+# или из корня репо:
+python3 -m loadtests.run <scenario> [опции]
+```
+
+Требования: Python 3.10+, `paho-mqtt` (`pip install paho-mqtt`).
+
+Конфигурация через env (дефолты — прод):
+
+| Env | Дефолт |
+|---|---|
+| `IOT_API` | `https://iot.containerk8s.dev.nubes.ru` |
+| `IOT_WS` | `wss://exqx.containerk8s.dev.nubes.ru/mqtt` |
+| `IOT_NS_PREFIX` | `lt` |
+| `IOT_CLEANUP` | `1` (удалять созданные тестом устройства) |
+
+Тест сам регистрирует устройства через API (JWT структурный) в namespace
+`lt_<run-id>` и удаляет их после прогона при `IOT_CLEANUP=1`.
+
+## Сценарии
+
+| Сценарий | Что проверяет |
+|---|---|
+| `baseline` | Равномерная нагрузка: потери/дубли/задержка (p50/p95/p99) доставки в PG. |
+| `burst` | Всплеск xN: рост очереди и время восстановления (recovery). |
+| `large-payload` | Payload до ~900KB (лимит EMQX 1MB). |
+| `reconnect-storm` | Периодические разрывы соединений (эмуляция edge-разрывов ~150с), QoS1. |
+| `multitenant` | Много namespace: задержка первого сообщения (EnsureTenantDB). |
+| `acl-violation` | Публикация в чужой топик → EMQX должен рвать сессию. |
+| `auth-neg` | Неверный пароль → CONNACK 4, неизвестный юзер → CONNACK 5. |
+| `api-crud` | Нагрузка на CRUD устройств (POST/GET/DELETE). |
+| `telemetry-query` | Нагрузка на чтение телеметрии. |
+| `soak` | Длительный прогон с периодическими срезами sent/delivered. |
+
+Примеры:
+
+```bash
+python3 -m loadtests.run baseline --devices 50 --rate 2 --duration 120 --qos 0
+python3 -m loadtests.run burst --devices 100 --rate 1 --burst-mult 10 --duration 30
+python3 -m loadtests.run reconnect-storm --devices 100 --rate 1 --reconnect-every 30 --duration 300
+python3 -m loadtests.run multitenant --tenants 20 --devices-per-tenant 3
+python3 -m loadtests.run api-crud --threads 10 --iterations 20
+python3 -m loadtests.run telemetry-query --threads 10 --iterations 50 --query-limit 100
+python3 -m loadtests.run soak --devices 50 --rate 1 --duration 3600 --slice-sec 300
+```
+
+## Ограничения
+
+- **SQS-лимит 256KB** на сообщение (shared-sqs отклоняет: `InvalidParameterValue
+  message size exceeds the limit`) → payload устройств ≤ ~250KB с учётом
+  envelope. Бридж дропает oversize с логом `payload too large for SQS`.
+  EMQX пропускает до 1MB, но узким местом конвейера является SQS.
+- API отдаёт максимум **1000 строк** телеметрии на запрос; шлюз платформы
+  рвёт ответы >~15КБ (баг MSS/MTU, тикет Nubes) → верификатор ходит
+  страницами по 50 (`offset`). Большие страницы НЕ использовать.
+- Задержка = `ts(PG) - sent_at - skew`; skew калибруется первым сообщением
+  (часы тест-машины и PG могут расходиться).
+- Consumer long-poll до ~20с → после публикаций нужна пауза перед сверкой
+  (встроена в сценарии).
+
+## Критерии успеха (базовые)
+
+- `baseline`: loss_rate = 0, duplicates = 0, p99 < 10с при ≤100 msg/s.
+- `burst`: recovery < 120с после конца пика.
+- `reconnect-storm`: loss_rate < 0.01 (QoS1), forced_reconnects > 0.
+- `acl-violation`: foreign_accepted = 0.
+- `auth-neg`: rc = 4 и rc = 5.
+- `soak`: delivered растёт монотонно, провалов нет.
+
+## Тесты с отключением сервисов (вручную, нужен kubectl с ВМ)
+
+Снаружи отключить SQS/PG нельзя — их блокируют на кластере:
+
+1. **SQS-outage** (обрыв бриджа): заблокировать egress монолита к shared-sqs
+   network policy или `kubectl delete endpoints` — 3 минуты, затем восстановить;
+   метрики: ошибки SendMessage в логах бриджа, время восстановления доставки.
+   (Известная проблема: SendMessage в handler блокирует MQTT-поток — см. HISTORY
+   секция 31, Sonnet-ревью, находка №1.)
+2. **PG-outage**: `kubectl -n <pg-ns> scale deployment postgresqlk8s --replicas=0`
+   на 5 минут; метрики: глубина SQS (ApproximateNumberOfMessages), дубли после
+   восстановления (visibility timeout 30с — см. находку №2 ревью).
+
+Оба теста — ТОЛЬКО на стенде, не на проде.
+
+## Что гонять на проде
+
+Умеренно (безопасно): `baseline` (≤100 msg/s), `auth-neg`, `acl-violation`,
+`api-crud`, `telemetry-query`, `multitenant` (≤20 тенантов).
+Осторожно (off-peak): `burst` (x10 кратко), `reconnect-storm` (≤100 устройств),
+`large-payload` (≤5 устройств).
+Не на проде: SQS-outage, PG-outage, `soak` >1ч с высоким rate.

loadtests/__init__.py

@@ -0,0 +1 @@
+# loadtests — набор нагрузочных тестов контура IoT.

loadtests/common.py

@@ -0,0 +1,139 @@
+# common.py — общие примитивы нагрузочных тестов IoT.
+#
+# Конфигурация через env (дефолты — прод-платформа):
+#   IOT_API       — базовый URL API (https://iot.containerk8s.dev.nubes.ru)
+#   IOT_WS        — wss URL EMQX (wss://exqx.containerk8s.dev.nubes.ru/mqtt)
+#   IOT_NS_PREFIX — префикс namespace для тестов (lt)
+#   IOT_CLEANUP   — удалять созданные устройства после теста (1)
+import base64
+import json
+import os
+import ssl
+import threading
+import time
+import urllib.request
+from urllib.parse import urlparse
+
+API = os.environ.get("IOT_API", "https://iot.containerk8s.dev.nubes.ru")
+WS = os.environ.get("IOT_WS", "wss://exqx.containerk8s.dev.nubes.ru/mqtt")
+NS_PREFIX = os.environ.get("IOT_NS_PREFIX", "lt")
+CLEANUP = os.environ.get("IOT_CLEANUP", "1") == "1"
+
+_ws = urlparse(WS)
+WS_HOST = _ws.hostname or ""
+WS_PORT = _ws.port or 443
+WS_PATH = _ws.path or "/mqtt"
+
+# Платформа рвёт внешние wss ~150с: паблишер должен уметь реконнектиться.
+EDGE_BREAK_SEC = 150
+
+
+def mint_jwt(sub="loadtest", ttl=86400):
+    h = base64.urlsafe_b64encode(b'{"alg":"none","typ":"JWT"}').rstrip(b"=").decode()
+    p = base64.urlsafe_b64encode(
+        json.dumps({"sub": sub, "exp": int(time.time()) + ttl}).encode()
+    ).rstrip(b"=").decode()
+    return h + "." + p + ".sig"
+
+
+class API:
+    """Тонкая обёртка над REST API монолита."""
+
+    def __init__(self, base=API):
+        self.base = base.rstrip("/")
+        self.token = mint_jwt()
+        self.ctx = ssl.create_default_context()
+        self.ctx.check_hostname = False
+        self.ctx.verify_mode = ssl.CERT_NONE
+
+    def _req(self, method, path, body=None):
+        url = self.base + path
+        data = json.dumps(body).encode() if body is not None else None
+        # Внешний путь платформы даёт таймауты ~31-33с (~5.5% запросов) —
+        # ретраи 3 с паузами (см. doc/sqs-integration.md, тикет Nubes).
+        last = None
+        for attempt in range(3):
+            try:
+                req = urllib.request.Request(
+                    url, data=data, method=method,
+                    headers={"Authorization": "Bearer " + self.token,
+                             "Content-Type": "application/json"},
+                )
+                with urllib.request.urlopen(req, timeout=15, context=self.ctx) as r:
+                    raw = r.read().decode()
+                    return json.loads(raw) if raw.strip() else {}
+            except Exception as e:
+                last = e
+                time.sleep(1 + attempt)
+        raise last
+
+    def create_device(self, ns, name, device_id):
+        return self._req("POST", f"/v1/namespaces/{ns}/iot/devices",
+                         {"name": name, "device_id": device_id})
+
+    def get_device(self, ns, name):
+        return self._req("GET", f"/v1/namespaces/{ns}/iot/devices/{name}")
+
+    def list_devices(self, ns):
+        return self._req("GET", f"/v1/namespaces/{ns}/iot/devices")
+
+    def delete_device(self, ns, name):
+        return self._req("DELETE", f"/v1/namespaces/{ns}/iot/devices/{name}")
+
+    def telemetry(self, ns, device_id="", limit=1000, offset=0):
+        q = f"?limit={limit}&offset={offset}"
+        if device_id:
+            q += f"&device_id={device_id}"
+        return self._req("GET", f"/v1/namespaces/{ns}/iot/telemetry{q}")
+
+
+class Counter:
+    """Потокобезопасные счётчики метрик."""
+
+    def __init__(self):
+        self._l = threading.Lock()
+        self.v = {}
+
+    def inc(self, key, n=1):
+        with self._l:
+            self.v[key] = self.v.get(key, 0) + n
+
+    def set(self, key, val):
+        with self._l:
+            self.v[key] = val
+
+    def get(self, key, default=0):
+        with self._l:
+            return self.v.get(key, default)
+
+    def snapshot(self):
+        with self._l:
+            return dict(self.v)
+
+
+def ws_tls_opts(client):
+    """wss с самоподписанным/платформенным сертификатом — без проверки."""
+    client.tls_set(cert_reqs=ssl.CERT_NONE)
+    client.tls_insecure_set(True)
+
+
+def percentile(values, q):
+    if not values:
+        return 0.0
+    s = sorted(values)
+    i = min(len(s) - 1, int(round(q * (len(s) - 1))))
+    return s[i]
+
+
+def latency_stats(ms_list):
+    return {
+        "n": len(ms_list),
+        "p50_ms": round(percentile(ms_list, 0.50), 1),
+        "p95_ms": round(percentile(ms_list, 0.95), 1),
+        "p99_ms": round(percentile(ms_list, 0.99), 1),
+        "max_ms": round(max(ms_list), 1) if ms_list else 0.0,
+    }
+
+
+def now_ms():
+    return int(time.time() * 1000)

loadtests/publisher.py

@@ -0,0 +1,147 @@
+# publisher.py — MQTT-паблишер: один поток на устройство.
+#
+# Каждый DevicePublisher:
+#   - подключается по wss (subprotocol mqtt), проверяет CONNACK через on_connect;
+#   - публикует в <ns>/telemetry/<device_id> с заданной частотой;
+#   - нумерует сообщения (seq) и кладёт sent_at (epoch ms) — для верификатора;
+#   - умеет периодически рвать соединение (reconnect_every) — эмуляция
+#     edge-разрывов платформы (~150с) и reconnect-storm;
+#   - ведёт метрики: sent, conn_ok, conn_fail, disconnects, connack_rc{...}.
+import json
+import ssl
+import threading
+import time
+
+import paho.mqtt.client as mqtt
+
+from .common import Counter, WS_HOST, WS_PATH, WS_PORT, now_ms, ws_tls_opts
+
+
+class DevicePublisher(threading.Thread):
+    def __init__(self, run_id, ns, device_id, username, password,
+                 rate=1.0, duration=60.0, qos=0, payload_size=128,
+                 reconnect_every=0, counter=None, extra_topic=None,
+                 publish_foreign=False):
+        super().__init__(daemon=True)
+        self.run_id = run_id
+        self.ns = ns
+        self.device_id = device_id
+        self.username = username
+        self.password = password
+        self.rate = rate            # сообщений/сек
+        self.duration = duration    # секунд
+        self.qos = qos
+        self.payload_size = payload_size
+        self.reconnect_every = reconnect_every  # 0 = не рвать
+        self.counter = counter or Counter()
+        self.extra_topic = extra_topic          # дополнительный (чужой) топик
+        self.publish_foreign = publish_foreign  # публиковать в чужой топик
+        self.connack_rc = None
+        self.disconnected = threading.Event()
+        self.stop = threading.Event()
+        self.topic = f"{ns}/telemetry/{device_id}"
+        self._connack = threading.Event()
+
+    # --- MQTT ---
+    def _on_connect(self, client, userdata, flags, rc, props=None):
+        self.connack_rc = rc
+        self.counter.inc(f"connack_rc{rc}")
+        if rc == 0:
+            self.counter.inc("conn_ok")
+        else:
+            self.counter.inc("conn_fail")
+        self._connack.set()
+
+    def _on_disconnect(self, client, userdata, rc, props=None):
+        self.counter.inc("disconnects")
+        self.disconnected.set()
+
+    def _client(self):
+        c = mqtt.Client(client_id=f"lt-{self.run_id}-{self.device_id}",
+                        transport="websockets")
+        c.ws_set_options(path=WS_PATH)
+        c.username_pw_set(self.username, self.password)
+        ws_tls_opts(c)
+        c.on_connect = self._on_connect
+        c.on_disconnect = self._on_disconnect
+        c.reconnect_delay_set(min_delay=2, max_delay=10)
+        return c
+
+    def _payload(self, seq):
+        pad = "x" * max(0, self.payload_size)
+        return json.dumps({
+            "run_id": self.run_id,
+            "seq": seq,
+            "sent_at": now_ms(),
+            "device_id": self.device_id,
+            "pad": pad,
+        })
+
+    def _connect(self, client, timeout=20):
+        self._connack.clear()
+        client.connect(WS_HOST, WS_PORT, timeout)
+        client.loop_start()
+        return self._connack.wait(timeout)
+
+    # --- поток ---
+    def run(self):
+        client = self._client()
+        seq = 0
+        t0 = time.monotonic()
+        next_t = t0
+        interval = 1.0 / self.rate if self.rate > 0 else 1.0
+        connected = False
+        last_reconnect = time.monotonic()
+
+        while not self.stop.is_set() and (time.monotonic() - t0) < self.duration:
+            if not connected:
+                if not self._connect(client):
+                    self.counter.inc("conn_fail")
+                    time.sleep(2)
+                    continue
+                connected = True
+
+            # периодический разрыв — эмуляция edge-разрывов платформы
+            if self.reconnect_every and \
+                    time.monotonic() - last_reconnect >= self.reconnect_every:
+                self.counter.inc("forced_reconnects")
+                client.disconnect()
+                client.loop_stop()
+                client = self._client()
+                connected = False
+                last_reconnect = time.monotonic()
+                continue
+
+            now = time.monotonic()
+            if now < next_t:
+                time.sleep(min(next_t - now, 0.5))
+                continue
+            next_t += interval
+            if next_t < now:  # отстали — не навёрстываем очередью
+                next_t = now + interval
+
+            payload = self._payload(seq)
+            r = client.publish(self.topic, payload, qos=self.qos)
+            if r.rc == mqtt.MQTT_ERR_SUCCESS:
+                self.counter.inc("sent")
+                seq += 1
+            else:
+                self.counter.inc("publish_errors")
+                # потеряли соединение — переподключимся
+                connected = False
+
+            if self.publish_foreign and self.extra_topic:
+                # ACL-тест: публикация в чужой топик должна разорвать сессию
+                self.counter.inc("foreign_publish")
+                client.publish(self.extra_topic, payload, qos=0)
+                if self.disconnected.wait(3):
+                    self.counter.inc("foreign_denied")
+                else:
+                    self.counter.inc("foreign_accepted")
+                    self.disconnected.clear()
+
+        try:
+            client.disconnect()
+            client.loop_stop()
+        except Exception:
+            pass

loadtests/run.py

@@ -0,0 +1,82 @@
+# run.py — CLI запуска нагрузочных сценариев.
+#
+# Примеры:
+#   python3 -m loadtests.run baseline --devices 50 --rate 2 --duration 120
+#   python3 -m loadtests.run burst --devices 100 --rate 1 --burst-mult 10 --duration 30
+#   python3 -m loadtests.run large-payload --payload-size 900000
+#   python3 -m loadtests.run reconnect-storm --devices 100 --reconnect-every 30
+#   python3 -m loadtests.run multitenant --tenants 20 --devices-per-tenant 3
+#   python3 -m loadtests.run acl-violation
+#   python3 -m loadtests.run auth-neg
+#   python3 -m loadtests.run api-crud --threads 10 --iterations 20
+#   python3 -m loadtests.run telemetry-query --threads 10 --iterations 50
+#   python3 -m loadtests.run soak --devices 50 --rate 1 --duration 3600 --slice-sec 300
+#
+# Общие ограничения:
+#   - на устройство максимум ~900 сообщений за сценарий (API отдаёт ≤1000 строк);
+#   - тест создаёт СВОИ устройства (namespace lt_*) и удаляет их при IOT_CLEANUP=1.
+import argparse
+import json
+
+from . import scenarios
+
+
+def main():
+    p = argparse.ArgumentParser(prog="loadtests")
+    sub = p.add_subparsers(dest="scenario", required=True)
+
+    def common(sp):
+        sp.add_argument("--devices", type=int, default=50)
+        sp.add_argument("--rate", type=float, default=1.0)
+        sp.add_argument("--duration", type=float, default=60.0)
+        sp.add_argument("--qos", type=int, choices=[0, 1], default=0)
+        sp.add_argument("--payload-size", type=int, default=128)
+        sp.add_argument("--reconnect-every", type=float, default=0.0)
+
+    s = sub.add_parser("baseline", help="равномерная нагрузка N устройств")
+    common(s)
+
+    s = sub.add_parser("burst", help="всплеск: тихо → пик → тихо, замер recovery")
+    common(s)
+    s.add_argument("--burst-mult", type=float, default=10.0)
+
+    s = sub.add_parser("large-payload", help="крупные payload (до ~900KB)")
+    common(s)
+
+    s = sub.add_parser("reconnect-storm", help="периодические разрывы соединений")
+    common(s)
+    s.set_defaults(reconnect_every=30, qos=1)
+
+    s = sub.add_parser("multitenant", help="много namespace, задержка первого сообщения")
+    s.add_argument("--tenants", type=int, default=20)
+    s.add_argument("--devices-per-tenant", type=int, default=3)
+    s.add_argument("--rate", type=float, default=0.2)
+    s.add_argument("--duration", type=float, default=60.0)
+    s.add_argument("--qos", type=int, choices=[0, 1], default=0)
+
+    sub.add_parser("acl-violation", help="публикация в чужой топик → отказ")
+
+    sub.add_parser("auth-neg", help="неверные креды → CONNACK 4/5")
+
+    s = sub.add_parser("api-crud", help="нагрузка на CRUD устройств")
+    s.add_argument("--threads", type=int, default=10)
+    s.add_argument("--iterations", type=int, default=20)
+
+    s = sub.add_parser("telemetry-query", help="нагрузка на чтение телеметрии")
+    s.add_argument("--threads", type=int, default=10)
+    s.add_argument("--iterations", type=int, default=50)
+    s.add_argument("--query-limit", type=int, default=100)
+    s.add_argument("--devices", type=int, default=10)
+
+    s = sub.add_parser("soak", help="длительный прогон со срезами")
+    common(s)
+    s.add_argument("--slice-sec", type=int, default=300)
+
+    args = p.parse_args()
+    fn = getattr(scenarios, args.scenario.replace("-", "_"))
+    report = fn(args)
+    print(json.dumps(report, ensure_ascii=False, indent=2, default=str))
+
+
+if __name__ == "__main__":
+    main()

loadtests/scenarios.py

@@ -0,0 +1,434 @@
+# scenarios.py — нагрузочные сценарии.
+#
+# Каждый сценарий: prepare → run → verify → report (dict) → cleanup.
+# Все устройства создаются самим тестом и помечены run_id; cleanup удаляет
+# только их (если IOT_CLEANUP=1).
+import json
+import threading
+import time
+
+from .common import API, CLEANUP, Counter, NS_PREFIX, latency_stats, now_ms
+from .publisher import DevicePublisher
+from .verifier import Verifier
+
+
+def _ns(run_id):
+    return f"{NS_PREFIX}_{run_id}"
+
+
+def _create_devices(api, ns, run_id, count, device_prefix="dev"):
+    devices = []
+    for i in range(count):
+        name = f"{device_prefix}{i}"
+        d = api.create_device(ns, name, f"{device_prefix}-{i}")
+        # POST возвращает устройство БЕЗ пароля — пароль только в GET по имени.
+        d = api.get_device(ns, name)
+        devices.append({
+            "name": name,
+            "device_id": d["device_id"],
+            "username": d["mqtt_username"],
+            "password": d["mqtt_password"],
+        })
+    return devices
+
+
+def _cleanup(api, ns, devices):
+    if not CLEANUP:
+        return
+    for d in devices:
+        try:
+            api.delete_device(ns, d["name"])
+        except Exception:
+            pass
+
+
+def _run_publishers(run_id, ns, devices, **kw):
+    """Запускает паблишеры, ждёт завершения, возвращает счётчики."""
+    counter = Counter()
+    pubs = [DevicePublisher(run_id, ns, d["device_id"], d["username"],
+                            d["password"], counter=counter, **kw)
+            for d in devices]
+    for p in pubs:
+        p.start()
+    for p in pubs:
+        p.join()
+    return counter.snapshot()
+
+
+def _wait_delivery(api, ns, run_id, devices, expected_total, timeout=120):
+    """Ждёт, пока доедет expected_total сообщений (или таймаут)."""
+    v = Verifier(api, ns, run_id)
+    t0 = time.monotonic()
+    while time.monotonic() - t0 < timeout:
+        per = sum(v.device_report(d["device_id"], 0)["delivered"]
+                  for d in devices)
+        rep = v.run_report(devices, expected_per_device=0)
+        if rep["delivered"] >= expected_total:
+            return rep, time.monotonic() - t0
+        time.sleep(5)
+    return v.run_report(devices, expected_per_device=0), time.monotonic() - t0
+
+
+# --------------------------------------------------------------------------
+# 1. BASELINE — равномерная нагрузка
+# --------------------------------------------------------------------------
+def baseline(args):
+    run_id = f"base-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    devices = _create_devices(api, ns, run_id, args.devices)
+    try:
+        expected_per_device = max(1, int(args.rate * args.duration))
+        t0 = now_ms()
+        counters = _run_publishers(
+            run_id, ns, devices, rate=args.rate, duration=args.duration,
+            qos=args.qos, payload_size=args.payload_size,
+            reconnect_every=args.reconnect_every)
+        send_ms = now_ms() - t0
+        time.sleep(10)  # consumer long-poll до ~20с
+        rep = Verifier(api, ns, run_id).run_report(
+            devices, expected_per_device)
+        rep.update({
+            "scenario": "baseline",
+            "ns": ns,
+            "send_ms": send_ms,
+            "publisher": counters,
+            "rate_rps": round(counters.get("sent", 0) / max(1, send_ms / 1000), 2),
+        })
+        return rep
+    finally:
+        _cleanup(api, ns, devices)
+
+
+# --------------------------------------------------------------------------
+# 2. BURST — всплеск
+# --------------------------------------------------------------------------
+def burst(args):
+    run_id = f"burst-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    devices = _create_devices(api, ns, run_id, args.devices)
+    try:
+        quiet = 20
+        spike = args.duration
+        low = _run_publishers(run_id + "-l", ns, devices,
+                              rate=args.rate, duration=quiet, qos=args.qos)
+        high = _run_publishers(run_id + "-h", ns, devices,
+                               rate=args.rate * args.burst_mult,
+                               duration=spike, qos=args.qos)
+        tail = _run_publishers(run_id + "-t", ns, devices,
+                               rate=args.rate, duration=quiet, qos=args.qos)
+        # Фазы различаются суффиксом run_id — верифицируем фазу "-h" отдельно.
+        high_sent = high.get("sent", 0)
+        expected_per_device = max(1, high_sent // max(1, len(devices)))
+        rep_high = Verifier(api, ns, run_id + "-h").run_report(
+            devices, expected_per_device)
+        # recovery: сколько времени после конца всплеска очередь отдала всё
+        _, recovery_s = _wait_delivery(
+            api, ns, run_id + "-h", devices, high_sent, timeout=300)
+        return {
+            "scenario": "burst",
+            "ns": ns,
+            "quiet_phase": low,
+            "spike_phase": high,
+            "tail_phase": tail,
+            "sent_high_total": high_sent,
+            "recovery_sec": round(recovery_s, 1),
+            "high": rep_high,
+        }
+    finally:
+        _cleanup(api, ns, devices)
+
+
+# --------------------------------------------------------------------------
+# 3. LARGE_PAYLOAD — крупные сообщения
+# Верификация через API невозможна: строка с большим payload в ответе >15 КБ,
+# а шлюз платформы рвёт такие ответы (баг MSS/MTU, тикет Nubes). Доставку
+# проверять по логам монолита: 'consumer: telemetry saved'.
+# --------------------------------------------------------------------------
+def large_payload(args):
+    run_id = f"big-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    devices = _create_devices(api, ns, run_id, min(args.devices, 10))
+    try:
+        counters = _run_publishers(
+            run_id, ns, devices, rate=args.rate, duration=args.duration,
+            qos=args.qos, payload_size=args.payload_size)
+        return {
+            "scenario": "large_payload",
+            "ns": ns,
+            "payload_size": args.payload_size,
+            "publisher": counters,
+            "note": "доставку смотреть в логах монолита (telemetry saved); "
+                    "API-верификация невозможна из-за бага шлюза (>15KB ответ)",
+        }
+    finally:
+        _cleanup(api, ns, devices)
+
+
+# --------------------------------------------------------------------------
+# 4. RECONNECT_STORM — массовые переподключения
+# --------------------------------------------------------------------------
+def reconnect_storm(args):
+    run_id = f"rc-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    devices = _create_devices(api, ns, run_id, args.devices)
+    try:
+        expected = max(1, int(args.rate * args.duration))
+        counters = _run_publishers(
+            run_id, ns, devices, rate=args.rate, duration=args.duration,
+            qos=1, reconnect_every=args.reconnect_every)
+        time.sleep(10)
+        rep = Verifier(api, ns, run_id).run_report(devices, expected)
+        rep.update({
+            "scenario": "reconnect_storm",
+            "ns": ns,
+            "publisher": counters,
+            "reconnect_every_sec": args.reconnect_every,
+        })
+        return rep
+    finally:
+        _cleanup(api, ns, devices)
+
+
+# --------------------------------------------------------------------------
+# 5. MULTITENANT — много namespace, задержка первого сообщения
+# --------------------------------------------------------------------------
+def multitenant(args):
+    run_id = f"mt-{int(time.time())}"
+    api = API()
+    devices_per_tenant = args.devices_per_tenant
+    all_devices = []
+    tenant_devices = {}
+    for t in range(args.tenants):
+        ns = _ns(f"{run_id}-{t}")
+        devs = _create_devices(api, ns, run_id, devices_per_tenant,
+                               device_prefix=f"t{t}")
+        tenant_devices[ns] = devs
+        all_devices.extend(devs)
+    try:
+        expected = max(1, int(args.rate * args.duration))
+        t0 = now_ms()
+        for ns, devs in tenant_devices.items():
+            _run_publishers(run_id, ns, devs, rate=args.rate,
+                            duration=args.duration, qos=args.qos)
+        time.sleep(15)
+        first_lats = []
+        for ns, devs in tenant_devices.items():
+            v = Verifier(api, ns, run_id)
+            for d in devs:
+                r = v.device_report(d["device_id"], expected)
+                if r["first_latency_ms"] is not None:
+                    first_lats.append(r["first_latency_ms"])
+        return {
+            "scenario": "multitenant",
+            "tenants": args.tenants,
+            "devices_per_tenant": devices_per_tenant,
+            "total_devices": len(all_devices),
+            "elapsed_ms": now_ms() - t0,
+            "first_msg_latency_ms": latency_stats(first_lats),
+        }
+    finally:
+        for ns, devs in tenant_devices.items():
+            _cleanup(api, ns, devs)
+
+
+# --------------------------------------------------------------------------
+# 6. ACL_VIOLATION — публикация в чужой топик
+# --------------------------------------------------------------------------
+def acl_violation(args):
+    run_id = f"acl-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    devices = _create_devices(api, ns, run_id, 2)
+    try:
+        victim_ns = _ns(f"{run_id}-victim")
+        victim = _create_devices(api, victim_ns, run_id, 1)[0]
+        attacker = devices[0]
+        foreign_topic = f"{victim_ns}/telemetry/{victim['device_id']}"
+        counter = Counter()
+        p = DevicePublisher(run_id, ns, attacker["device_id"],
+                            attacker["username"], attacker["password"],
+                            rate=1, duration=10, qos=0, counter=counter,
+                            extra_topic=foreign_topic, publish_foreign=True)
+        p.start()
+        p.join()
+        return {
+            "scenario": "acl_violation",
+            "ns": ns,
+            "publisher": counter.snapshot(),
+            "expect": "foreign_denied=все, foreign_accepted=0 "
+                      "(EMQX рвёт сессию: deny_action=disconnect)",
+        }
+    finally:
+        _cleanup(api, ns, devices)
+
+
+# --------------------------------------------------------------------------
+# 7. AUTH_NEG — отказ на неверные креды
+# --------------------------------------------------------------------------
+def auth_neg(args):
+    import paho.mqtt.client as mqtt
+
+    from .common import WS_HOST, WS_PATH, WS_PORT, ws_tls_opts
+
+    def attempt(client_id, username, password):
+        res = {}
+        c = mqtt.Client(client_id=client_id, transport="websockets")
+        c.ws_set_options(path=WS_PATH)
+        c.username_pw_set(username, password)
+        ws_tls_opts(c)
+
+        def on_connect(cl, ud, flags, rc, props=None):
+            res["rc"] = rc
+        c.on_connect = on_connect
+        try:
+            c.connect(WS_HOST, WS_PORT, 15)
+            c.loop_start()
+            time.sleep(2)
+            c.loop_stop()
+        except Exception as e:
+            res["exc"] = type(e).__name__
+        return res
+
+    results = {
+        "wrong_password": attempt("lt-neg-pass", "test_dev-001", "wrong-123"),
+        "unknown_user": attempt("lt-neg-user", "nosuch_user", "whatever"),
+    }
+    return {"scenario": "auth_neg",
+            "expect": "wrong_password rc=4, unknown_user rc=5",
+            "results": results}
+
+
+# --------------------------------------------------------------------------
+# 8. API_CRUD — нагрузка на CRUD устройств
+# --------------------------------------------------------------------------
+def api_crud(args):
+    run_id = f"api-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    lat = {"POST": [], "GET": [], "DELETE": []}
+    lock = threading.Lock()
+    errors = Counter()
+
+    def worker(wid):
+        for i in range(args.iterations):
+            name = f"w{wid}-{i}"
+            for op, fn in (
+                ("POST", lambda: api.create_device(ns, name, f"w{wid}-{i}")),
+                ("GET", lambda: api.get_device(ns, name)),
+                ("DELETE", lambda: api.delete_device(ns, name)),
+            ):
+                t0 = now_ms()
+                try:
+                    fn()
+                    with lock:
+                        lat[op].append(now_ms() - t0)
+                except Exception:
+                    errors.inc(op)
+
+    threads = [threading.Thread(target=worker, args=(w,))
+               for w in range(args.threads)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    return {
+        "scenario": "api_crud",
+        "ns": ns,
+        "threads": args.threads,
+        "iterations_per_thread": args.iterations,
+        "POST": latency_stats(lat["POST"]),
+        "GET": latency_stats(lat["GET"]),
+        "DELETE": latency_stats(lat["DELETE"]),
+        "errors": errors.snapshot(),
+    }
+
+
+# --------------------------------------------------------------------------
+# 9. TELEMETRY_QUERY — нагрузка на чтение телеметрии
+# --------------------------------------------------------------------------
+def telemetry_query(args):
+    run_id = f"tq-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    devices = _create_devices(api, ns, run_id, max(1, args.devices))
+    try:
+        # сидируем данные
+        _run_publishers(run_id, ns, devices, rate=5, duration=20, qos=0)
+        time.sleep(10)
+        lat = []
+        lock = threading.Lock()
+        errors = Counter()
+
+        def worker(wid):
+            for _ in range(args.iterations):
+                t0 = now_ms()
+                try:
+                    api.telemetry(ns, limit=args.query_limit)
+                    with lock:
+                        lat.append(now_ms() - t0)
+                except Exception:
+                    errors.inc("query")
+
+        threads = [threading.Thread(target=worker, args=(w,))
+                   for w in range(args.threads)]
+        t0 = now_ms()
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+        elapsed = max(1, (now_ms() - t0) / 1000)
+        return {
+            "scenario": "telemetry_query",
+            "ns": ns,
+            "threads": args.threads,
+            "iterations": args.iterations,
+            "query_limit": args.query_limit,
+            "req_per_sec": round(len(lat) / elapsed, 2),
+            "latency": latency_stats(lat),
+            "errors": errors.snapshot(),
+        }
+    finally:
+        _cleanup(api, ns, devices)
+
+
+# --------------------------------------------------------------------------
+# 10. SOAK — длительный прогон с периодическими срезами
+# --------------------------------------------------------------------------
+def soak(args):
+    run_id = f"soak-{int(time.time())}"
+    ns = _ns(run_id)
+    api = API()
+    devices = _create_devices(api, ns, run_id, args.devices)
+    try:
+        counter = Counter()
+        pubs = [DevicePublisher(run_id, ns, d["device_id"], d["username"],
+                                d["password"], rate=args.rate,
+                                duration=args.duration, qos=args.qos,
+                                counter=counter) for d in devices]
+        for p in pubs:
+            p.start()
+        v = Verifier(api, ns, run_id)
+        t0 = now_ms()
+        slices = []
+        while any(p.is_alive() for p in pubs):
+            time.sleep(args.slice_sec)
+            sent = counter.get("sent")
+            rep = v.run_report(devices, 0)
+            slices.append({
+                "elapsed_sec": int((now_ms() - t0) / 1000),
+                "sent": sent,
+                "delivered": rep["delivered"],
+            })
+            print(json.dumps(slices[-1]))
+        for p in pubs:
+            p.join()
+        expected = max(1, int(args.rate * args.duration))
+        rep = v.run_report(devices, expected)
+        rep.update({"scenario": "soak", "ns": ns, "slices": slices})
+        return rep
+    finally:
+        _cleanup(api, ns, devices)

loadtests/verifier.py

@@ -0,0 +1,102 @@
+# verifier.py — проверка доставки: потери, дубли, задержка.
+#
+# Схема: паблишер кладёт в payload run_id + seq + sent_at (epoch ms).
+# Верификатор читает телеметрию через API и сверяет:
+#   - delivered  — сколько строк с run_id дошло;
+#   - lost       — сколько seq не доехало;
+#   - duplicates — сколько seq приехало более одного раза;
+#   - latency    — ts(PG) - sent_at (epoch ms). Точность зависит от
+#                  синхронизации часов тест-машины и платформы (обе NTP).
+from datetime import datetime
+
+from .common import latency_stats
+
+
+def _ts_to_ms(ts):
+    """'2026-08-16T14:23:22.363648+03:00' → epoch ms (UTC)."""
+    try:
+        return datetime.fromisoformat(ts).timestamp() * 1000
+    except (ValueError, TypeError):
+        return None
+
+
+class Verifier:
+    def __init__(self, api, ns, run_id):
+        self.api = api
+        self.ns = ns
+        self.run_id = run_id
+
+    def device_report(self, device_id, expected):
+        """Сверка по одному устройству. expected — сколько seq ждали.
+        Пагинация по 50 строк: шлюз платформы рвёт ответы >~15 КБ
+        (баг MSS/MTU, тикет Nubes) — большие страницы НЕ использовать."""
+        rows = []
+        offset = 0
+        pages = 0
+        while pages < 40:
+            page = self.api.telemetry(self.ns, device_id=device_id,
+                                      limit=50, offset=offset)
+            items = page.get("items", [])
+            rows.extend(items)
+            pages += 1
+            offset += 50
+            if len(items) < 50 or len(rows) >= max(expected + 100, 200):
+                break
+        seqs = {}
+        for r in rows:
+            p = r.get("payload") or {}
+            if p.get("run_id") != self.run_id:
+                continue
+            s = p.get("seq")
+            if s is None:
+                continue
+            seqs.setdefault(s, []).append(
+                (r.get("ts"), p.get("sent_at"))
+            )
+        delivered = len(seqs)
+        lost = max(0, expected - delivered)
+        duplicates = sum(len(v) - 1 for v in seqs.values() if len(v) > 1)
+        lat = []
+        first_lat = None
+        for s, entries in seqs.items():
+            ts, sent = entries[0]
+            ts_ms = _ts_to_ms(ts) if ts else None
+            if ts_ms is not None and isinstance(sent, (int, float)):
+                l = max(0.0, ts_ms - sent)
+                lat.append(l)
+                if s == 0:
+                    first_lat = l
+        return {
+            "device_id": device_id,
+            "expected": expected,
+            "delivered": delivered,
+            "lost": lost,
+            "duplicates": duplicates,
+            "lat_ms": lat,
+            "latency": latency_stats(lat),
+            "first_latency_ms": round(first_lat, 1) if first_lat is not None else None,
+        }
+
+    def run_report(self, devices, expected_per_device):
+        """Сводка по всем устройствам. Возвращает dict метрик."""
+        total_expected = expected_per_device * len(devices)
+        total_delivered = total_lost = total_dups = 0
+        per = []
+        all_lat = []
+        for d in devices:
+            r = self.device_report(d["device_id"], expected_per_device)
+            per.append(r)
+            total_delivered += r["delivered"]
+            total_lost += r["lost"]
+            total_dups += r["duplicates"]
+            all_lat += r["lat_ms"]
+        return {
+            "devices": len(devices),
+            "expected": total_expected,
+            "delivered": total_delivered,
+            "lost": total_lost,
+            "loss_rate": round(total_lost / total_expected, 6) if total_expected else 0.0,
+            "duplicates": total_dups,
+            "latency": latency_stats(all_lat),
+            "per_device": per,
+        }

ws-probe/Dockerfile

@@ -0,0 +1,17 @@
+# ws-probe — проверка WebSocket через платформенный ingress Nubes.
+# Образ: naeel/iot-ws-probe (Docker Hub, публичный — платформа тянет только публичные).
+
+FROM golang:1.25 AS builder
+WORKDIR /workspace
+COPY go.mod go.sum ./
+RUN go mod download
+COPY main.go ./
+ARG VERSION=dev
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -ldflags "-X main.version=${VERSION}" -o ws-probe .
+
+FROM gcr.io/distroless/static:nonroot
+WORKDIR /
+COPY --from=builder /workspace/ws-probe .
+USER 65532:65532
+EXPOSE 8080
+ENTRYPOINT ["/ws-probe"]