Оркестрация AI-агентов с помощью Rivet
Разбор архитектуры Rivet: использование модели акторов и S3 для масштабирования агентных нагрузок без тяжелых песочниц для каждого экземпляра.
Проблема масштабирования агентных систем
Проблема масштабирования агентных систем
Когда агентных экземпляров становится больше десяти, вопрос перестаёт быть «как запустить» и превращается в «как не уронить инфраструктуру под собственным весом». Каждый агент — это не просто процесс, это контекст разговора, история вызовов инструментов, промежуточные результаты и часто тяжёлые вложения. Если запускать каждого в отдельной песочнице, скоро упираешься в память и время холодного старта.
Rivet предлагает другой подход: модель акторов плюс объектное хранилище S3 для больших артефактов. Вместо того чтобы тащить с собой полноценную ОС на каждый экземпляр, агент существует как лёгкий актор с состоянием, а тяжёлые данные выносятся за пределы вычислительного узла.
Ограничения традиционных песочниц
Традиционные песочницы — Docker-контейнеры, виртуальные машины или микро-VM вроде Firecracker — рассчитаны на изоляцию рабочих нагрузок, а не на высокую плотность кратковременных экземпляров. Каждый контейнер тянет за собой overlay-файловую систему, сетевой стек и минимум нескольких сотен мегабайт оперативной памяти просто на то, чтобы существовать.
Во-первых, холодный старт. Если агенту нужно ответить на запрос пользователя, а контейнер поднимается 3–5 секунд, пользователь уже закрыл вкладку. Для интерактивных агентов это неприемлемо.
Во-вторых, изоляция дорогая. Допустим, у вас 200 агентов, каждый в своём контейнере с лимитом 512 МБ. Это уже 100 ГБ только на ОЗУ, не считая самого хоста и оркестратора. На одном сервере такое не разместишь.
С практической точки зрения, ограничения выглядят так:
yaml# Пример лимитов Docker для одного агента
deploy:
resources:
limits:
cpus: '0.5'
memory: 512M
reservations:
memory: 256M
Умножьте на количество агентов — и получите представление, почему классическая контейнеризация не масштабируется до тысяч экземпляров на одном хосте. Если мы посмотрим на архитектуру Rivet, там нет необходимости держать отдельный контейнер на каждого актора. Агент живёт в рамках общего runtime, а его состояние хранится отдельно.
Потребление ресурсов при высокой плотности агентов
При высокой плотности агентов узкое место смещается с процессора на память и дисковый ввод-вывод. Каждый актор хранит историю диалога, промежуточные результаты вызовов инструментов и, возможно, вложения (embeddings) для семантического поиска. Если всё это держать в оперативной памяти, сервер упрется в swap ещё до того, как процессор загрузится на 50 %.
Если мы посмотрим на типичное состояние агента, оно состоит из трёх частей:
- Выполнение — код агента и текущий контекст LLM (оперативная память).
- Состояние — история сообщений, переменные сессии, результаты инструментов (база данных).
- Артефакты — логи, сгенерированные файлы, выгрузки моделей (объектное хранилище).
Для состояния подходит PostgreSQL, если нужны реляционные связи и надёжность, или Redis, если важна скорость доступа к сессиям. SQLite удобен для локального хранения на одном узле, но не масштабируется за пределы одного сервера. Я уже писал про редактирование SQLite‑базы данных в браузере, но для агентной системы на нескольких нодах SQLite станет узким местом. Если нужен Redis-совместимый кэш на одной ноде, стоит присмотреться к KiviDB.
С артефактами проще: они не нужны агенту в горячем пути, поэтому их выносят в S3. Это освобождает локальный диск и даёт предсказуемость при росте объёма данных. Пример конфигурации хранения:
toml[storage]
backend = "s3"
endpoint = "https://s3.example.com"
bucket = "rivet-artifacts"
region = "ru-central1"
[database]
primary = "postgres://rivet:password@db.internal:5432/rivet"
cache = "redis://redis.internal:6379/0"
Если сравнить с традиционным подходом, где каждый агент пишет логи в свой контейнер, а потом вы их собираете через sidecar, здесь всё проще: актор завершил задачу — результат ушёл в S3, память освободилась.
Ещё один момент — сетевой трафик. При высокой плотности агентов начинают доминировать вызовы к LLM API и междусервисное взаимодействие. Если все агенты сидят на одном хосте и ломятся в один PostgreSQL, получите конфликт за подключения. Пул соединений и реплики чтения здесь обязательны. Я уже описывал локальную систему задач с PostgreSQL в этой статье, и многие принципы переносятся на агентную нагрузку.
Кратко: традиционные песочницы не подходят для массовых агентных систем из-за избыточной изоляции и медленного старта. При высокой плотности ключевым ресурсом становится память, а не процессор, поэтому состояние и артефакты нужно выносить из runtime в базу и объектное хранилище.
Архитектура Rivet и модель акторов
Архитектура Rivet и модель акторов
Когда агентов становится больше двух‑трёх, вопрос встаёт остро: как запускать сотни экземпляров, не разворачивая для каждого отдельный контейнер или виртуальную машину. Тяжелые песочницы съедают память и замедляют запуск, а агентная нагрузка по сути событийная — агент простаивает 99 % времени и ожидает сообщения.
Rivet решает это через модель акторов. Каждый агент — это актор с собственным изолированным состоянием. Акторы обмениваются сообщениями, а не вызывают методы друг друга напрямую. Состояние не держится в памяти постоянно: актор просыпается, загружает данные, обрабатывает событие и засыпает обратно. Благодаря этому можно держать тысячи агентов на одном хосте, а при необходимости масштабироваться на edge‑платформах вроде Cloudflare.
В этом разделе разберём, как устроены легковесные акторы Rivet и почему состояние агентов удобно выносить в S3.
Принцип работы легковесных акторов
Легковесный актор в Rivet — это не полноценный процесс и даже не контейнер. Это объект с состоянием и почтовым ящиком. Сообщения кладутся в очередь, актор забирает их по одному, обновляет состояние и отправляет ответные сообщения другим акторам. Пока нет сообщений, актор не потребляет CPU.
На практике это выглядит так. Определяем актора агента:
typescriptinterface AgentState {
sessionId: string;
context: Record<string, unknown>;
lastMessageAt: Date;
}
class SupportAgent extends RivetActor<AgentState> {
async onMessage(message: { text: string; userId: string }) {
this.state.lastMessageAt = new Date();
this.state.context[message.userId] = message.text;
// Сохраняем состояние, чтобы не потерять при выгрузке из памяти
await this.saveState();
return { reply: `Принято: ${message.text}` };
}
}
Ключевое отличие от обычного микросервиса — актор не отвечает за весь жизненный цикл запроса. Он только обрабатывает одно сообщение за раз. Если нужно выполнить сложную цепочку действий, разбиваем её на несколько сообщений между акторами. Это даёт предсказуемость: каждый актор делает одну вещь, и отлаживать такое проще, чем монолитный оркестратор.
Для хранения метаданных о сессиях можно использовать PostgreSQL или SQLite, в зависимости от масштаба. Если агенты работают на одном узле, SQLite достаточно. Для кластера — PostgreSQL. Redis подходит для кэширования часто запрашиваемых состояний, но не для основного хранилища.
Пример запуска актора в Rivet:
bash# Регистрируем тип актора
rivet actor register support-agent ./dist/support-agent.js
# Запускаем воркер, который будет обслуживать акторы этого типа
rivet worker start --actor-type support-agent --concurrency 64
Параметр --concurrency 64 означает, что один вордер может одновременно обрабатывать 64 актора. Это не 64 контейнера — это 64 контекста выполнения в одном процессе. Потребление памяти растёт линейно с числом активных акторов, а не с числом зарегистрированных.
Организация состояния агентов в S3
Поскольку акторы выгружаются из памяти между сообщениями, состояние нужно где-то хранить. Rivet позволяет выносить снимки состояния в объектное хранилище, например S3. Каждый актор получает свой ключ в бакете, где лежит сериализованное состояние.
Схема работы такая:
- Актор получает сообщение.
- Загружает состояние из S3 по ключу
actors/{actorType}/{actorId}.json. - Обрабатывает сообщение, обновляет состояние в памяти.
- Сохраняет обновлённое состояние обратно в S3.
- Освобождает память.
Такой подход избавляет от необходимости держать для каждого агента отдельную песочницу с постоянным потреблением ОЗУ. Актор может жить на любом узле кластера — главное, чтобы был доступ к S3.
Пример конфигурации хранилища в rivet.yaml:
yamlactors:
defaultStateStore: s3
stateStore:
type: s3
bucket: rivet-agent-states
region: eu-central-1
endpoint: https://s3.example.com
prefix: actors/
snapshotInterval: 30s
snapshotInterval задаёт, как часто Rivet делает промежуточные снимки состояния. Если актор обрабатывает сообщения редко, состояние сохраняется после каждого сообщения. Если часто — пакетами, чтобы не нагружать сеть.
Код актора с явным управлением состоянием:
typescriptclass DocumentAgent extends RivetAgent<{ draft: string; version: number }> {
async onMessage(message: { edit: string }) {
// Загружаем состояние из S3 (Rivet делает это автоматически,
// но можно переопределить для тонкой настройки)
const state = await this.loadState();
state.draft = message.edit;
state.version += 1;
// Сохраняем в S3. Rivet добавит версионирование ключа,
// чтобы не потерять данные при параллельной записи.
await this.saveState(state);
return { saved: true, version: state.version };
}
}
Важный нюанс: при параллельной записи двух сообщений одному актору Rivet ставит их в очередь. Состояние не пострадает, но задержка между сообщениями одного актора растёт. Если нужна высокая пропускная способность для одного агента, разбивайте его на несколько акторов по шардам (например, по ID пользователя).
Для шифрования чувствительных данных в состоянии можно применить клиентское шифрование перед отправкой в S3. Подробнее про такой подход можно почитать в материале Шифрование данных на стороне клиента с ULDA.
Если нужно быстро посмотреть или поправить состояние агента, не поднимая консоль управления S3, удобно использовать браузерные инструменты для работы с базами. Хотя Rivet хранит состояние в S3, для отладки связанных метаданных в SQLite пригодится Редактирование SQLite‑базы данных в браузере.
Для локальных экспериментов с агентными задачами и PostgreSQL можно развернуть простую систему задач — например, по материалу Настройка 3 & Done: локальная система задач с голосовым вводом и PostgreSQL. А если нужен быстрый кэш для состояний, стоит посмотреть на KiviDB: быстрая Redis-совместимая БД на Rust.
Итог раздела простой: легковесные акторы убирают необходимость в тяжелых песочниках, а S3 даёт надёжное и дешёвое хранение состояния. В следующей части разберём, как organiser взаимодействие между акторами и какие ограничения накладывает такая архитектура на отказоустойчивость.
Практическая реализация оркестрации
Управление жизненным циклом рабочих нагрузок
В Rivet каждый AI-агент работает как актор — независимая единица, которая получает сообщения, обрабатывает их и меняет своё состояние. С практической точки зрения это означает, что нам не нужно поднимать отдельный контейнер на каждого агента. Это было бы как арендовать целый офисный этаж для одного сотрудника: ресурсы простаивают, а управление раздувается.
Жизненный цикл агента в Rivet выглядит так:
- Агент запускается по триггеру — входящему запросу или сообщению из очереди.
- Он загружает своё состояние из хранилища. Rivet использует S3 для хранения артефактов и снимков состояния, чтобы агент мог продолжить работу с того места, где остановился.
- Агент обрабатывает задачу и записывает результат обратно.
- После завершения агент останавливается, освобождая память и CPU.
Для метаданных — кто какой агент, где его состояние, какая версия кода — подходит PostgreSQL. Redis используется для быстрых очередей и промежуточного кеширования. Если вам нужна Redis-совместимая база на Rust, ознакомьтесь с KiviDB: быстрая Redis-совместимая БД на Rust. Если агенту нужно локальное хранилище без сетевых задержек, Rivet может использовать SQLite на диске ноды.
Пример конфигурации агента может выглядеть так:
yamlagent:
name: "document-processor"
runtime: "nodejs"
entrypoint: "src/index.js"
state:
backend: "s3"
bucket: "rivet-agent-states"
region: "eu-central-1"
metadata:
backend: "postgres"
connection_string: "postgres://rivet:password@db.internal:5432/rivet"
queue:
backend: "redis"
url: "redis://cache.internal:6379/0"
lifecycle:
max_idle_seconds: 300
max_memory_mb: 512
Важный момент: состояние агента должно быть сериализуемым. Если агент хранит открытые соединения с базой или файловые дескрипторы в памяти, после перезапуска он их потеряет. Поэтому я рекомендую выносить все внешние соединения за пределы актора и восстанавливать их при каждом запуске.
Для управления процессами на хосте я использую systemd. Это позволяет перезапускать агента при сбое и ограничивать потребление ресурсов:
ini[Unit]
Description=Rivet Agent: document-processor
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/rivet-agent --config /etc/rivet/agent.yaml
Restart=on-failure
RestartSec=5
MemoryMax=512M
CPUQuota=50%
[Install]
WantedBy=multi-user.target
После применения конфига не забудьте выполнить:
bashsudo systemctl daemon-reload
sudo systemctl enable rivet-agent@document-processor
sudo systemctl start rivet-agent@document-processor
Такой подход даёт предсказуемое поведение: агент либо работает, либо перезапускается systemd, либо останавливается по истечении таймаута простоя.
Обеспечение предсказуемости при масштабировании
Когда агентов становится больше десяти, появляется проблема предсказуемости. Не в том смысле, что мы знаем, что скажет агент, а в том, что мы знаем, сколько ресурсов он съест и когда остановится.
С практической точки зрения предсказуемость строится на трёх вещах: лимитах, мониторинге и правильном выборе хранилища.
Во-первых, лимиты. В конфиге выше я уже задал MemoryMax и CPUQuota. Без них один зацикленный агент может съесть всю память ноды и вывести из строя соседей. Это особенно критично, если вы размещаете Rivet на своём оборудовании вместе с другими сервисами.
Во-вторых, мониторинг. Я использую Prometheus со сборщиком метрик systemd и Grafana для визуализации. Ключевые метрики:
- количество активных агентов по типам;
- время жизни агента от запуска до остановки;
- размер состояния в S3 на одного агента;
- задержка в очереди Redis.
Если очередь в Redis растёт быстрее, чем агенты успевают обрабатывать сообщения, это сигнал добавить нод или увеличить лимиты.
В-третьих, выбор хранилища. S3 отлично подходит для хранения больших артефактов — логов, промежуточных результатов, вложений. Но для частых чтений и записей состояния он может стать узким местом из-за задержек сети. В таких случаях я выношу горячее состояние в локальный SQLite на диске ноды, а в S3 отправляю только снимки раз в несколько минут или при остановке агента.
Пример скрипта для создания снимка состояния:
bash#!/bin/bash
# Создаёт снимок состояния агента в S3
AGENT_ID=$1
STATE_DIR="/var/lib/rivet/agents/${AGENT_ID}"
S3_BUCKET="rivet-agent-states"
if [ ! -d "${STATE_DIR}" ]; then
echo "State directory not found: ${STATE_DIR}" >&2
exit 1
fi
aws s3 cp "${STATE_DIR}/state.db" "s3://${S3_BUCKET}/${AGENT_ID}/state-$(date +%s).db"
Если вы используете Cloudflare для доставки контента или как внешнее хранилище через R2, Rivet может взаимодействовать с ним по протоколу S3 — интерфейс совместим, и менять код агента не придётся.
При масштабировании на несколько нод важно помнить: агент должен иметь возможность запуститься на любой ноде и продолжить работу. Для этого состояние должно быть доступно из сетевого хранилища (S3, R2 или общий NFS), а не только на локальном диске одной машины.
Что касается баз данных: PostgreSQL подходит для реляционных метаданных, Redis — для очередей, а SQLite — для локального кэша состояния. Если вам интересен практический опыт работы с PostgreSQL в локальных задачах, посмотрите Настройку 3 & Done: локальная система задач с голосовым вводом и PostgreSQL. Для высокой доступности метаданных разворачивайте PostgreSQL в кластере с репликами. Для небольших нагрузок достаточно одной ноды с регулярным бэкапом.
Предсказуемость конфигураций — это не про идеальный код, а про чёткие границы. Агент знает, сколько памяти ему выделено. Система знает, когда перезапустить агента. Вы знаете, куда смотреть, если что-то пошло не так.
Сравнение с существующими подходами
Сравнение с существующими подходами
Когда речь заходит о запуске десятков или сотен AI-агентов, первое, что приходит в голову — упаковать каждого в отдельный Docker-контейнер. Подход понятный, изолированный, но дорогой по ресурсам. Каждый контейнер тянет свой образ, свою файловую систему, свой сегмент памяти. Если агент простаивает 95 % времени, ресурсы всё равно выделены.
Rivet предлагает иную модель. Вместо контейнера на агента — актор в общем рантайме. Акторы обмениваются сообщениями, состояние хранятся централизованно, а вычисления происходят там, где свободны ресурсы. Ниже разберём, чем это отличается от классических контейнеров и как обстоят дела с задержками при доступе к данным.
Rivet против классических контейнеров
Классический подход с Docker выглядит так: один образ на агента, один контейнер на экземпляр. Если нужно запустить 50 агентов, поднимаем 50 контейнеров. Каждый из них изолирован на уровне ядра Linux, имеет свой сетевой стек, свои ограничения по памяти и CPU. Это удобно для развёртывания, но избыточно для агентных нагрузок, где большая часть времени агент ждёт ответа от модели или внешнего API.
В Rivet используется модель акторов. Акторы — это легковесные единицы вычисления, живущие в общем процессе рантайма. Они не требуют полноценной изоляции ОС, потому что взаимодействие между ними регулируется самим фреймворком: сообщения, почтовые ящики, надзор за состоянием. Состояние актора не лежит в локальном слое контейнера, а выносится во внешнее хранилище — в данном случае S3. Это значит, что актор можно остановить на одной ноде и запустить на другой, не таская с собой гигабайты образа.
Сравним на практике. Допустим, у нас есть простой агент, который обрабатывает входящие запросы и пишет результат в базу.
Docker Compose для пяти агентов:
yamlversion: "3.8"
services:
agent-1:
image: my-ai-agent:latest
environment:
- AGENT_ID=agent-1
- S3_BUCKET=agent-state
mem_limit: 512m
cpus: "0.5"
agent-2:
image: my-ai-agent:latest
environment:
- AGENT_ID=agent-2
- S3_BUCKET=agent-state
mem_limit: 512m
cpus: "0.5"
# ... ещё три агента
Каждый агент тянет по 512 МБ памяти и по 0.5 ядра, даже если реально потребляет 50 МБ в простое.
В Rivet конфигурация выглядит иначе. Один рантайм, несколько акторов:
yamlruntime:
nodes:
- host: 192.168.1.10
roles: [compute, storage]
storage:
type: s3
bucket: agent-state
region: eu-central-1
actors:
- id: agent-1
type: processor
concurrency: 10
- id: agent-2
type: processor
concurrency: 10
Здесь нет отдельных образов на каждого агента. Есть один рантайм, который планирует акторы по доступным нодам. Память выделяется под фактическую нагрузку, а не под worst-case сценарий контейнера.
С практической точки зрения это даёт два эффекта. Во-первых, плотность размещения выше: на том же железе можно держать больше агентов. Во-вторых, время запуска актора измеряется миллисекундами, а не секундами, как у контейнера с cold start.
Конечно, у контейнеров есть свои преимущества — полная изоляция, возможность запустить разные версии зависимостей для разных агентов, привычные инструменты мониторинга. Но если ваша нагрузка — это сотни однотипных агентов, которые в основном ждут I/O, контейнеры становятся избыточной обёрткой.
Производительность и задержки при доступе к данным
Когда состояние агентов вынесено в S3, возникает закономерный вопрос: не убьёт ли сетевая задержка производительность? Ответ — зависит от того, как вы organiseте доступ к данным.
S3 — это объектное хранилище с задержкой в десятки миллисекунд. Если каждый актор перед каждым действием будет скачивать своё состояние из S3, а после — загружать обратно, система станет медленной. Поэтому в архитектуре Rivet используется иерархия хранения.
Горячие данные — в памяти или в быстрой БД. Теплые — в PostgreSQL или Redis. Холодные — в S3. Актор загружает состояние при старте, работает с локальной копией, а изменения синхронизируются обратно асинхронно.
Пример схемы взаимодействия:
- Актор запускается, загружает состояние из S3 в локальный SQLite-файл.
- В процессе работы пишет промежуточные результаты в Redis (TTL 5 минут).
- Каждые 30 секунд или при завершении задачи сбрасывает итоговое состояние обратно в S3.
Для локального кэширования удобно использовать SQLite — он не требует отдельного сервера, работает как файл, и подходит для хранения состояния одного актора. Если нужно что-то более быстрое, подойдёт Redis или его Rust-аналог KiviDB, о котором мы уже писали ранее.
Вот как может выглядеть конфигурация доступа к данным для актора:
toml[actor.state]
# Холодное хранилище — первичное место хранения
backend = "s3"
bucket = "agent-state"
region = "eu-central-1"
# Горячее кэширование
cache = "redis"
cache_url = "redis://10.0.0.5:6379"
cache_ttl = 300
# Локальное состояние для быстрого доступа внутри актора
local_db = "sqlite"
local_db_path = "/var/lib/rivet/actor-1/state.db"
# Синхронизация
sync_interval = "30s"
sync_on_shutdown = true
Если в вашей инфраструктуре уже есть PostgreSQL, его можно использовать как промежуточное звено между S3 и акторами. Например, для хранения метаданных о задачах агентов, а само состояние — в S3. Мы уже рассматривали локальную систему задач с PostgreSQL в одном из руководств, и многие из тех принципов применимы здесь.
Что касается задержек, то в реальных условиях доступ к S3 из того же региона занимает от 50 до 200 мс. Для агентных нагрузок, где один шаг рассуждения может занимать секунды из-за вызова LLM, эта задержка не критична. Критична она становится, если акторы обмениваются мелкими сообщениями через S3 каждые несколько миллисекунд. В таких случаях стоит оставить S3 только для долговременного хранения, а для межакторного взаимодействия использовать Redis или встроенную шину сообщений рантайма.
Ещё один нюанс — безопасность данных. Если состояние агентов содержит конфиденциальную информацию, её стоит шифровать ещё на стороне клиента, перед отправкой в S3. Мы подробно разбирали такой подход в статье про шифрование на стороне клиента с ULDA.
Итог простой: Rivet не убирает задержки полностью, но позволяет управлять ими осознанно. Горячие данные — рядом с актором, холодные — в S3, а между ними выбираете инструмент по задаче: SQLite для локального состояния, Redis для кэша, PostgreSQL для реляционных метаданных.