Перейти к содержимому
AggregaAggrega
Выберите язык: Русский
Эта страница переведена машинным способом. Читать оригинал на английском.

Features для ИИ

Набор Feature для ИИ в Aggrega

Чтобы отвечать особым требованиям, изменчивости и угрозам безопасности современных систем ИИ, Aggrega встраивает специализированный интеллект непосредственно в свою открытую стандартную библиотеку ИИ (Каталог). Это гарантирует, что как общий cloud-native каркас, так и узкоспециализированные ИИ-нативные механизмы рассуждения безопасно сосуществуют.

Основной компилятор на Go — это универсальный маршрутизатор, нейтральный к содержимому; весь специфичный для ИИ интеллект находится в подключаемых политиках WebAssembly (Wasm) и в объявлениях JSON Schema 2020-12, которые архитекторы платформы создают на сущностях Каталога.

1. Операционная облачная онтология и утиная типизация для ИИ

Чтобы связать общую Open Application Model (OAM) со строгими реалиями современной инфраструктуры, метка component.aggrega.ai/type отображается исключительно на закрытый набор универсальных cloud-native примитивов. Именно эту семантическую идентичность читают селектор сокета, appliesTo сущности Feature и политика управления, чтобы знать, как компонент обращается с состоянием, входящим сетевым трафиком и жизненными циклами; компилятор сопоставляет её как непрозрачную строку и не ветвится по ней, а то, как рендерится компонент, определяет сущность Recipe, с которой сущность Manifest его сопоставляет.

Cloud-native типы (инфраструктурная основа):

  • server: долго работающие вычисления без состояния, которые ожидают входящего трафика приложения (например, AI Gateway или Chat UI).
  • worker: долго работающие вычисления без состояния, которые забирают задания из очередей или выполняют фоновые циклы без каких-либо входящих портов приложения (например, агент LangGraph или воркер Celery).
  • task: эфемерные вычисления, которые выполняются до завершения и останавливаются (например, скрипты миграции БД).
  • function: событийно-управляемые вычисления, масштабируемые до нуля (например, AWS Lambda).
  • stateful-server: вычисления в кластере, требующие стабильных сетевых идентичностей и постоянных дисков (например, векторная база данных Qdrant, брокер Kafka).
  • resource: внешняя инфраструктура, управляемая платформой (например, AWS RDS PostgreSQL, бакеты S3, размещённая шина событий).

Набор принадлежит Aggrega и является закрытым. Опубликованная схема сущности Component перечисляет эти значения, а документ с любым другим значением отклоняется при загрузке — E0215 называет метку и перечисляет, какие значения она принимает. Именно это даёт ось: Feature или селектор сокета, написанный относительно stateful-server, означает одно и то же в каждом каталоге, с которым сталкивается.

То, чем компонент является в вашем собственном словаре, записывается в ваш собственный ключ. Уровень, зона данных, класс сервиса, более мелкое разделение примитивов — каждое из них является ключом метки, который вы создаёте рядом с зарезервированным, поскольку схема сущности Component принимает любой дополнительный ключ метки со строковым значением, и каждая поверхность селекторов считывает его одинаково. Это тот же механизм, который уже используют описанные ниже метки утиной типизации для ИИ; зарезервированный ключ — общая основа, а всё, что выше, принадлежит вам.

Операционный тип — это не категория для просмотра, и это намеренно отдельные оси. Брокер Kafka находится в категории messaging — там, где пользователь его ищет, — и несёт stateful-server в качестве своего типа, потому что именно это инфраструктура должна для него обеспечить. Селектор, написанный относительно одной оси, никогда не совпадает на другой.

Таблицы таксономии семантических меток см. в entities/component — метки Generic Cloud Layer, Specialized AI Layer, Cross-Cutters и Dynamic Business Context, которыми архитекторы наслаивают когнитивную идентичность поверх базовых типов.


1.1 Стандарт открытого каталога: «Голая основа, специализированные края»

При применении этих меток существует критическое различие между Официальным открытым каталогом Aggrega (core/*) и Частным корпоративным каталогом (acme/*).

Чтобы официальный открытый каталог оставался универсально применимым, он должен строго различать неизменяемую техническую физику и субъективное когнитивное намерение. Если в универсальный core/datastore/postgres жёстко зашито engine: relational, плагин вердикта управления, настроенный на принудительное соответствие типа хранилища данных, остановит сборку, когда разработчик включит расширение pgvector в своих values и попытается подключить агента ИИ, которому требуется хранилище данных vector.

Чтобы основной каталог оставался без собственного мнения, официальные компоненты следуют такому стандарту: оставляйте основу голой, а края специализируйте.

  1. Голая основа: открытая сущность Component корневого уровня жёстко задаёт только то, что объективно верно для продукта и не может быть изменено ничем, что настраивает автор, — прежде всего и всегда операционный примитив (component.aggrega.ai/type). База данных Postgres объективно является stateful-server; этот факт не может измениться. Тот же критерий допускает метку возможности там, где идентичность продукта и есть эта возможность: core/datastore/qdrant и core/datastore/weaviate — это движки векторного поиска, и ничто, что пишет автор, не делает их чем-то другим, поэтому каждый из них несёт datastore.aggrega.ai/engine: vector на основе, точно так же как core/datastore/redis несёт kv. То, что голая основа отвергает, — противоположный случай: признак, зависящий от того, как компонент настроен или используется, для которого существует третий механизм, описанный ниже.
  2. Специализированные интерфейсы (наследование схемы): сущность Component может объявить extends, назвав другую сущность Component своей основой, и то, что при этом компонуется, — это структура: метки, аннотации, слоты вложений, список разрешённых самовнедрений, сокеты топологии и именованные assertions. Три столпа данных не компонуются — расширяющая сущность Component записывает буквальный маркер schema: inherited и не создаёт собственного содержимого values, infra или provides, поэтому её контракт идентичен контракту основы. Именно поэтому механизм сужает, а не варьирует: поскольку контракт не меняется, каждая сущность Recipe, написанная для основы, уже обслуживает специализацию, а специализация стоит одну сущность каталога и одну строку отображения в сущности Manifest. Следовательно, то, что добавляет специализация, — это идентичность, которую считывает селектор или политика: уровень аудита, зона данных, контакт по вопросам управления или сокет, чей селектор допускает меньше, чем селектор основы. Она не может добавить другой контракт, потому что у неё нет поверхности, на которой его можно было бы создать. Одно следствие легко упустить: строка отображения всё равно нужна. Выбор сущности Recipe выполняется по точному ключу отображения, поэтому специализации нужна собственная запись mappings.components.type, даже если ей не нужна собственная сущность Recipe. См. examples/extends-wrapper — опубликованный wrapper, который добавляет метку проверенного уровня и сужает по ней сокет, вместе со сборкой, которая останавливается, когда ребро, подключённое к этому сокету, выходит за пределы уровня. Признак, зависящий от того, как настроен компонент, не является предметом этого механизма: специализация закрепляет артефакт своей основы и наследует её контракт, поэтому признак, верный для специализации, уже верен для основы, куда его помещает правило голой основы. Такой признак относится к динамическому мутатору, описанному ниже.
  3. Динамический мутатор (Wasm-продвижение): если признак диктуется полезной нагрузкой разработчика (например, enable_vector: true), предприятие использует роль label-transform сокета управления при построении топологии, чтобы динамически прочитать непрозрачные values и автоматически внедрить метку datastore.aggrega.ai/engine: vector в граф IR до запуска политик. Именно здесь признак, зависящий от конфигурации, становится доступен для строгого вычисления политик — его продвигают values, объявленные разработчиком, а преобразование выполняется до того, как какая-либо политика прочитает метку.

Корпоративное исключение: поскольку компилятор без собственного мнения, предприятия, создающие собственные внутренние каталоги, вольны нарушать это правило. Если корпоративная политика безопасности предписывает, что все внутренние базы данных являются высокочувствительными, архитектор платформы может и должен жёстко задать compliance.aggrega.ai/data-class: restricted (или аналогичную метку, определённую компанией) непосредственно в своём базовом компоненте acme/postgres, чтобы каждый его экземпляр нёс этот класс, а политика, подключённая предприятием, считывала его на каждом из них. Сама метка ничего не принуждает: компилятор переносит её как строку, а сборку останавливает именно подключённая политика. Там, где такие данные содержат лишь некоторые из применений продукта в ИТ-ландшафте организации, класс вместо этого несёт специализация через extends — см. examples/policy-data-class-route, где ассистент по страховым претензиям — это агент LangGraph из стандартной библиотеки плюс одна метка класса, рядом с политикой, которая её считывает.

1.2 Как семантические метки управляют конвейером компилятора

Чтобы метки оставались в домене архитектора платформы, разработчики не могут записывать метки на своих экземплярах Component внутри Aggregate: схема сущности Aggregate не даёт экземпляру компонента ключа labels. Метки узла — это метки его сущности каталога вместе с теми, которые добавляет во время построения топологии вложение управления label-transform, настроенное оператором. Вот как именно эти метки управляют конвейером компиляции без необходимости писать собственный код на Go:

1. component.aggrega.ai/type (базовый примитив)

  • Кто её записывает? Архитектор платформы (домен 2). Она обязательна для каждого компонента в каталоге.
  • Кто её потребляет? Статический анализатор и Plugins рендеринга Wasm.
  • Применение в компиляторе: это основная операционная облачная онтология. Статический анализатор нативно на Go вычисляет строки селекторов usesSchema, чтобы гарантировать, что разработчик не сможет подключить агента к стандартной базе данных, если сокет требует определённой возможности ИИ. Кроме того, DevOps использует эту метку, чтобы явно направлять примитивы с состоянием (stateful-server, resource) в физические границы кластера, поддерживающие постоянные диски, а роль вердикта управления может требовать, чтобы компоненты с состоянием никогда не размещались в исключительно эфемерных границах.

2. model.aggrega.ai/capability

  • Кто её записывает? Архитектор платформы.
  • Кто её потребляет? Статический анализатор (через селекторы меток в стиле Kubernetes у сокетов usesSchema).
  • Применение в компиляторе: когда архитектор создаёт селектор usesSchema, называющий требуемую метку возможности, нативный механизм сопоставления меток компилятора отклоняет связи, не удовлетворяющие селектору, ещё до генерации артефактов. Компилятор рассматривает эти метки как непрозрачные строки; семантическое значение «text-generation» в отличие от «embedding» заложено в том, как архитектор создаёт селектор.

3. component.aggrega.ai/hosting

  • Кто её записывает? Архитектор платформы.
  • Кто её потребляет? Механизм политик (роль вердикта управления), Plugins рендеринга Wasm и собственные компоненты стандартной библиотеки, вызывающие модель или агента: её агенты, чьё утверждение считывает метку на каждом соединении model, core/ai-tool/agent-invocation, чьё утверждение считывает её на его соединении target_agent, как и его реализация для Kubernetes, отказывающая в учётных данных агенту external, к которому обращаются по http, шлюз ИИ, чьё утверждение считывает её на каждом соединении с его сокетами models и cache_store, а также core/gateway/kong, core/gateway/kong-enterprise, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/traefik-hub, core/gateway/agentgateway и core/gateway/higress, чьи утверждения считывают её на каждом соединении с их сокетами models, а также с backend обоих Kong, с сокетами cache_store APISIX и Traefik Hub и с сокетами cache Envoy Gateway, Higress и Traefik Hub — см. «Ключ, который предъявляет вызывающая сторона» ниже.
  • Применение в компиляторе: она фиксирует, кто эксплуатирует базовый ресурс компонента, позволяя политике, подключённой оператором, оценивать риск эксфильтрации данных; компилятор читает значение как строку и ничего не оценивает. Когда агент, чья метка класса указывает, что он содержит данные internal, подключается к модели с меткой managed — сервису, эксплуатируемому за пределами собственной границы сущности Release, — такая политика может прочитать, что данные покидают эту границу, и остановить сборку, если соединение не направлено через шлюз ИИ с core/data-masking, который маскирует текст чата и дополнений, пересылаемый шлюзом. Сокет model агента принимает такой шлюз вместо модели, поэтому этот маршрут является ребром графа, который читает политика, а модель, которую шлюз обслуживает из своего сокета models, является отдельным ребром — от шлюза к компоненту модели, метки которого читает политика, — так что путь от агента через шлюз к модели managed присутствует в графе от начала до конца. Upstream, вписанный вручную в карту моделей шлюза, — нет: это строка, которую компилятор не разрешает, поэтому политика, читающая граф, видит шлюз и ничего за ним. examples/policy-data-class-route — именно такая политика: её настройки относят модель managed к классу public, и она останавливает сборку, в которой ассистент с данными restricted достигает такой модели без маскирующего шлюза на маршруте. Это сквозной признак: те же значения self-hosted | managed | external описывают управляемую базу данных или самостоятельно развёрнутый сервер инференса так же, как и модель, поэтому метка находится в общем пространстве имён component.aggrega.ai/, а не в пространстве, специфичном для моделей.

4. agent.aggrega.ai/autonomy

  • Кто её записывает? Архитектор платформы.
  • Кто её потребляет? Механизм политик (роль вердикта управления).
  • Применение в компиляторе: она определяет риск выполнения когнитивного цикла. Если агент помечен как autonomous (то есть выполняет фоновые циклы без запросов пользователя) и подключается к высокочувствительной базе данных, механизм политик может остановить сборку, если автор не подключит ту Feature одобрения или сдерживания, которую требуют собственные правила предприятия, чтобы цикл без надзора не мог добраться до этих данных без проверки.
  • Что означает компонент без метки на этой оси, ведь отсутствие намеренно. Метка описывает риск выполнения когнитивного цикла, поэтому компонент, не содержащий собственного цикла, не несёт здесь никакого значения, а не меньшее из двух. Довольно многие компоненты в категории агентов не имеют метки именно по этой причине: вспомогательные части, которые платформа агентов поставляет рядом со своим сервером, — консоль в браузере, запуск миграции схемы, task worker, песочница для кода, прокси исходящего трафика — находятся в этой категории, потому что именно там вы их ищете, тогда как цикл, который они поддерживают, живёт в сервере платформы, и именно там стоит метка. Самый наглядный случай — один продукт, разделённый между обоими подходами: сервер платформы несёт copilot, а песочница для кода, поставляемая рядом, не несёт ничего. Критерий — где живёт цикл, а не какую форму имеет часть, поэтому среда выполнения, размещающая код агента, предоставленный вами, тоже не имеет метки: цикл там — это то, что вы в неё развернёте, а не что-то, что утверждает продукт. Поэтому селектор, называющий любое из двух значений, совпадает с компонентами, содержащими цикл, и ни с какими другими, а селектор, написанный для совпадения с любым уровнем автономности, пропускает вспомогательные части, а не считает их наименее автономными элементами развёртывания.

5. gateway.aggrega.ai/intelligence

  • Кто её записывает? Архитектор платформы.
  • Кто её потребляет? Статический анализатор и созданные предприятием плагины-линтеры Wasm.
  • Применение в компиляторе: она определяет, какие функции маршрутизатор может физически поддерживать. Feature для ИИ fallback-chain объявляет appliesTo: gateway.aggrega.ai/intelligence=semantic, а статический анализатор вычисляет этот селектор относительно меток целевого компонента до рендеринга какого-либо артефакта. Если разработчик подключит её к стандартному шлюзу l4-mesh, сборка останавливается с нарушением селектора, которое называет Feature и селектор, которому она не удовлетворила, потому что архитектор создал этот селектор, зная, что стандартная TCP-сетка не может разбирать JSON-нагрузки LLM, чтобы прочитать модель, названную в запросе. Отказ основан на отсутствии semantic, а не на наличии l4-mesh, поэтому он так же действует на маршрутизаторе, который вообще не несёт метки интеллекта. Компилятор рассматривает метку как непрозрачную строку, точно так же, как выше: значение semantic заложено в том, как архитектор создаёт селектор. На маршрутизаторе, который несёт semantic, подключение проходит селектор, а то, что происходит дальше, зависит от его реализации: реализация из стандартной библиотеки записывает цепочку в конфигурацию маршрутизации шлюза ИИ.
  • Что содержит стандартная библиотека. Эти компоненты несут semantic: core/gateway/litellm, реализация которого рендерит таблицу маршрутизации прокси — карту моделей поверх нескольких upstream-провайдеров; core/gateway/cloudflare-ai-gateway, размещённый шлюз Cloudflare, который читает каждый пересылаемый им запрос к модели — модель, которую он называет, токены, за которые выставляется счёт, и, когда включены собственные проверки шлюза, его содержимое; core/gateway/azure-api-management, шлюз ИИ в Azure API Management, размещённый сервис, который читает каждый запрос к модели на API, обслуживающем модель, — промпт, который сравнивает его семантический кеш, токены, о которых сообщает ответ, и содержимое, которое его проверка безопасности отправляет на инспекцию; core/gateway/apisix, прокси ИИ которого читает тело каждого запроса на маршруте, обслуживающем модель, и токены, о которых сообщает ответ модели; core/gateway/envoy-gateway, расширение Envoy AI Gateway которого читает тело каждого запроса на маршруте, обслуживающем подключённые к нему модели, чтобы найти названную модель, а также токены, о которых сообщает каждый ответ; core/gateway/kong-enterprise, Kong Gateway Enterprise, прокси ИИ которого читает тело каждого запроса на маршруте, обслуживающем подключённую модель, — названную модель и сообщения, которые он несёт, — а также токены, о которых сообщает каждый ответ; core/gateway/traefik-hub, Traefik Hub, middleware Chat Completion которого читает тело каждого запроса на маршруте, обслуживающем подключённую модель, проверяет его по схеме chat completion и читает токены, о которых сообщает каждый ответ; core/gateway/agentgateway, agentgateway, который читает тело каждого запроса на своих путях обслуживания моделей, чтобы найти названную модель, — именно так он выбирает подключённую модель, которой отправляется запрос, — а также токены, о которых сообщает каждый ответ; и core/gateway/higress, Higress, прокси ИИ которого читает тело каждого запроса на маршруте, обслуживающем подключённую модель, — названную модель и то, используется ли потоковая передача, — а плагины которого читают токены, о которых сообщает каждый ответ, — так что Features для ИИ, требующие этого значения, разрешаются относительно любого из них, и каждая реализация указывает, что из этого поддерживает её шлюз, или останавливает сборку там, где её шлюз не поддерживает ничего из этого; Feature без реализации для данного шлюза останавливает там сборку, называя свой тип. Ни один компонент не несёт l4-mesh, а остальные компоненты шлюзов из стандартной библиотеки вообще не несут метки интеллекта: те, что маршрутизируют трафик, терминируют HTTP и маршрутизируют на уровне 7, а один из них является плоскостью управления, которая вообще ничего не маршрутизирует, поэтому ни одно из двух значений его не описывает. TCP-сетка уровня 4 — это ещё один, иной класс продуктов. Поэтому описанный выше отказ остаётся полностью в силе, ведь он основан на отсутствии semantic: подключение, требующее этого значения, останавливается на любом из них. Архитектор, чей каталог действительно запускает сетку уровня 4, ставит на этот компонент l4-mesh, что делает различие доступным для выбора в обоих направлениях.
  • Эта ось называет уровень продукта, а это другой вопрос, чем то, что компонент может делать с трафиком, и читать её во втором смысле — ошибка, к которой она располагает. semantic означает, что маршрутизатор разбирает тело запроса, а именно это нужно контролю, действующему на модель, названную в запросе, — поэтому для этого она и является правильной осью. Она ничего не говорит о том, может ли маршрутизатор копировать трафик, передавать идентичность вызывающей стороны, проверять сертификат upstream, отклонять prompt, совпадающий со списком шаблонов, или вести бюджет за период, и сущности Feature, которой нужна одна из этих возможностей, незачем спрашивать об уровне: большинство компонентов, которые их предлагают, — обычные прокси уровня 7 без какого-либо значения intelligence, а там, где маршрутизатор semantic предлагает одну из них, он делает это по причинам, которые уровень не фиксирует. Таким образом, уровень охватывает неверное множество в обоих направлениях — он полностью исключает простые прокси и ничего не говорит о том, какими возможностями на самом деле обладает AI-шлюз, который он охватывает. Этот вопрос относится к описанной ниже оси пути данных, и обе оси сочетаются — сущность Feature может потребовать маршрутизатор semantic, который также выполняет зеркалирование, назвав оба значения.

6. tool.aggrega.ai/impact

  • Кто её записывает? Архитектор платформы.
  • Кто её использует? Движок политик и Plugins Wasm для рендеринга.
  • Применение в компиляторе: Перенос этой информации из изменяемого блока values разработчика в неизменяемую идентичность меток позволяет движку политик оценивать строгие конфигурации с минимальными привилегиями. Плагин рендеринга может сгенерировать стандартные разрешения invoke для инструмента веб-поиска read-only, но потребовать строгих конфигураций криптографической подписи для вызова инструмента mutating, выполняющего SQL drop.

7. compliance.aggrega.ai/data-class

  • Кто её записывает? Архитектор платформы собственного каталога ИТ-ландшафта организации (или она динамически внедряется через роль управления label-transform).
  • Кто её потребляет? Механизм политик (роль вердикта управления).
  • Применение в компиляторе: Она даёт данным, которые хранит компонент, идентичность в рамках управления, по которой политика может следовать вдоль графа. Компилятор переносит метку в граф IR как строку и ничего не ранжирует: он не знает, что restricted чувствительнее, чем public, и что какое-либо из этих слов вообще что-то означает. Политика, присоединённая к роли ir-verdict, задаёт это значение в собственных настройках — какие классы существуют и как они ранжируются — и читает метку на компонентах маршрутов, которые компилятор перечисляет по рёбрам uses, поэтому она может остановить сборку, в которой компонент с данными restricted достигает компонента другого класса по маршруту, на котором не присоединена ни одна сущность Feature, считающаяся политикой понижающей класс, например core/data-masking на AI-шлюзе, через который проходит маршрут. Перечисление ограничено для каждого начального компонента и не перечисляет ничего за пределом, поэтому маршрут, который читает политика, реален, тогда как отсутствие маршрута не доказывает, что его не существует. examples/policy-data-class-route — это такая политика, написанная для движков Rego и CEL, встроенных в CLI, и для OPA, с останавливающимися сборками и завершающейся сборкой рядом друг с другом.
  • Что содержит стандартная библиотека. Ни одна сущность Component core/ не несёт эту метку. Класс данных компонента — это утверждение о том, как организация использует компонент, а не свойство продукта, истинное в каждой сущности Release, поэтому по правилу Naked Base метка остаётся вне базы: организация размещает её на собственной сущности Component — специализации через extends, как ассистент по страховым случаям в разобранном примере, или собственной базе в рамках описанного выше Enterprise Exception.

8. hardware.aggrega.ai/accelerator

  • Кто её записывает? Архитектор платформы. Упаковывая компонент локальной модели, он знает, что для работы тому принципиально нужен GPU.
  • Кто её использует? DevOps (домен 4).
  • Применение в компиляторе: DevOps явно направляет компоненты с меткой GPU в границы пулов физического оборудования в Release через карту components: {}. Разработчик просто запрашивает когнитивную модель в своём Aggregate, а DevOps размещает её в границе дорогого кластера GPU, полностью сохраняя разделение ответственности. Роль вердикта управления может дополнительно требовать, чтобы ни один компонент с этой меткой никогда не размещался в границе без инфраструктуры GPU.

9. datastore.aggrega.ai/engine

  • Кто её записывает? Архитектор платформы, на компонентах категории datastore (статически, на flavored-специализации или через роль label-transform, когда values разработчика повышают роль). Значения, используемые в каталоге: relational, document, kv, vector, graph, semantic-memory, search. Каждое значение называет движок хранения, которым продукт является, — search называет движок поиска и аналитики, который также индексирует векторы, — поэтому черта, живущая в собственной схеме и шаблоне доступа приложения, а не в каком-либо развёртываемом хранилище, не является значением на этой оси.
  • Кто её использует? Статический анализатор (через строки селекторов) и движок политик.
  • Применение в компиляторе: Селекторы нацелены на семантику хранения, а не на продукты, — сокет базы знаний агента выбирает datastore.aggrega.ai/engine in (vector, semantic-memory, search), а движок политик может отклонить маршрутизацию SQL-нагрузок к векторному движку. Релевантность для AI у хранилищ данных двойного назначения выводится из этой метки и никогда не хранится как отдельное булево значение.
  • Что содержит стандартная библиотека. core/datastore/qdrant, core/datastore/weaviate, core/datastore/chroma, core/datastore/pgvector и core/datastore/milvus несут vector, core/datastore/cognee несёт semantic-memory, а core/datastore/opensearch и core/datastore/elasticsearch несут search, поэтому приведённый выше селектор базы знаний разрешается относительно каждого из них. core/datastore/redis, core/datastore/valkey и core/datastore/memcached несут kv. Каждая из этих меток находится на собственной базе компонента, потому что идентичность продукта — это именно этот движок. Для core/datastore/pgvector эта идентичность — артефакт, который он закрепляет: он запускает собственный образ PostgreSQL проекта pgvector, содержащий расширение, и каждая сущность Recipe включает расширение в базе данных, которую создаёт компонент, — поэтому его векторная черта не зависит от настройки, и именно это отличает его от описанного выше в «Naked Base, Flavored Edges» настраиваемого случая, где PostgreSQL общего назначения получает эту черту только тогда, когда разработчик включает расширение. У relational, document и graph нет компонента в стандартной библиотеке, поэтому селектор, называющий только значения из их числа, здесь ничему не соответствует и удовлетворяется каталогом, который содержит такой компонент.

10. pipeline.aggrega.ai/mode

  • Кто её записывает? Архитектор платформы, на компонентах категории pipeline. Каждое значение называет, как продукт выполняет многошаговое задание, и значения следуют за компонентами, которые их несут, а не за заранее заданным списком. Стандартная библиотека содержит два: durable на core/ai-pipeline/temporal, движок которого записывает результат каждого шага как историю событий и воспроизводит её, так что задание, worker которого аварийно завершился, продолжается с того места, где остановилось; и reconciled на core/ai-pipeline/argo-workflows, контроллер которого запускает каждый шаг как pod из ресурса workflow, хранящегося в собственном API кластера.
  • Кто её использует? Движок политик и Plugins Wasm для рендеринга.
  • Применение в компиляторе: Позволяет политикам и рендерерам различать движки конвейеров по тому, как запуск переживает сбой, — воспроизведённая история событий или согласованный ресурс кластера, — а не по названию продукта.

11. dataplane.aggrega.ai/* (Возможности пути данных)

  • Кто её записывает? Архитектор платформы, на любом компоненте, стоящем на пути трафика, — обратном прокси, входном шлюзе, service mesh, AI-шлюзе.
  • Кто её использует? Статический анализатор, через appliesTo сущности Feature и селектор usesSchema сокета.
  • Применение в компиляторе: Она отвечает на вопрос, что этот компонент может делать с трафиком, — именно это действительно нужно знать контролю во время выполнения и именно этого не может сказать метка уровня продукта. core/traffic-shadowing, который копирует живые запросы во второй сервис для оценки, объявляет appliesTo: dataplane.aggrega.ai/request-mirroring — только ключ, — и статический анализатор оценивает это относительно меток цели до того, как что-либо будет отрендерено, поэтому присоединение его к компоненту, который вообще не умеет зеркалировать, останавливает сборку с нарушением селектора, называющим сущность Feature и селектор, которому она не удовлетворила. Компилятор считает каждую из этих строк непрозрачной, точно так же, как и остальные.
  • Почему префикс называет путь трафика, а не вид компонента. Зеркалирование, идентичность вызывающей стороны и проверка upstream — не свойства шлюза: это свойства всего, что стоит на пути запроса, и service mesh, добавленный в каталог, обладает всеми тремя. Назвать семейство по виду компонента, который случайно нёс их первым, значило бы заставить каждый следующий вид повторять тот же словарь под собственным префиксом, оставив одну возможность с несколькими названиями и без селектора, способного охватить их все.
  • Почему точность записана в значении. Два компонента могут оба зеркалировать запросы и всё же различаться так, как это важно для сущности Feature: один копирует каждый подходящий запрос, другой — настраиваемую долю из них. Ключ, который говорил бы лишь, зеркалирует ли компонент, допустил бы оба и оставил бы разницу для обнаружения после рендеринга. Размещение точности в значении позволяет запрашивать её тем из двух способов, который подходит сущности Feature. Сущность Feature, которая вообще не может работать без определённой точности, называет это значение в своём селекторе. Сущность Feature, которая работает и при более низкой точности, выбирает только по ключу, а её реализация отклоняет настройку, которую компонент не может выполнить: копирование всего потока работает на любом компоненте, который зеркалирует, поэтому core/traffic-shadowing присоединяется ко всем им, а реализация для компонента, объявляющего full-rate, отклоняет долю ниже 100 сообщением, называющим запрошенную долю и точность, объявленную компонентом, — две вещи, которых нарушение селектора не говорит. Поэтому значения выводятся из того, что реализуют поставляемые продукты, а не составляются как таксономия: request-mirroring несёт full-rate и sampled, потому что реальные прокси делятся именно так — один предлагает настройку частоты копирования, а другой не предлагает никакой.
  • Значение утверждает возможность, но никогда не настроенное состояние. Для разработчика оба читаются одинаково, и лишь одно из них является свойством компонента. Прокси, способный проверять сертификат upstream, несёт upstream-tls: trust-anchor независимо от того, включает ли какое-либо развёртывание эту проверку, — метка — это то, по чему сущность Feature выбирает, прежде чем что-либо настроено, поэтому нагружать её конфигурацией значило бы сделать её нечитаемой именно в момент использования.
  • Что содержит стандартная библиотека. core/gateway/nginx несёт request-mirroring: full-rate, upstream-tls: trust-anchor и concurrency-cap: total — одно ограничение на все пересылаемые им запросы. core/gateway/contour несёт request-mirroring: sampled, caller-identity: client-certificate и upstream-tls: trust-anchor. core/gateway/envoy-gateway несёт те же три значения, что и core/gateway/contour, а также period-budget: tokens, подсчитывающее токены, о которых сообщает каждый ответ модели, обслуживаемой им через Envoy AI Gateway, и concurrency-cap: per-target — ограничение на выполняющиеся запросы к каждой обслуживаемой им модели. core/gateway/kong несёт upstream-tls: trust-anchor и prompt-guard: pattern-list: его AI Prompt Guard сопоставляет сообщения запроса к модели со списками, которые содержат его маршруты. core/gateway/tyk несёт upstream-pinning: public-key, которое выбирает core/upstream-key-pinning. core/gateway/litellm несёт caller-identity: injected-header, content-masking: entity-recognition, period-budget: cost, prompt-guard: pattern-list, upstream-tls: trust-anchor и concurrency-cap: per-target — ограничение на выполняющиеся запросы к каждой записи его карты моделей. core/gateway/cloudflare-ai-gateway несёт period-budget: cost. core/gateway/apisix несёт period-budget: tokens, подсчитывающее токены, о которых сообщает ответ каждой модели, ничего не оценивая в деньгах, и prompt-guard: pattern-list. core/gateway/kong-enterprise несёт period-budget: tokens, подсчитывающее токены, о которых сообщает ответ каждой модели, и content-masking: entity-recognition. core/gateway/traefik-hub несёт content-masking: entity-recognition и prompt-guard: pattern-list: его middleware Content Guard маскирует совпадения шаблонов, содержащихся в его конфигурации, или типы сущностей, обнаруженные вызываемым им анализатором Presidio, либо отклоняет запрос, которому соответствует шаблон, — а также period-budget: cost с ценами из поставляемого с его middleware квот прайс-листа для каждой модели, который вместо этого может подсчитывать токены, о которых сообщает каждый ответ. core/gateway/agentgateway несёт content-masking: pattern-list и prompt-guard: pattern-list: его защита на основе регулярных выражений маскирует или отклоняет совпадения шаблонов, содержащихся в его конфигурации, и не распознаёт никаких типов сущностей, — а также period-budget: cost, бюджеты, которые он ведёт для каждого ключа API в долларах США с ценами из его каталога стоимости моделей или в токенах. core/gateway/higress несёт content-masking: pattern-list: его плагин ai-data-masking маскирует совпадения шаблонов, содержащихся в его конфигурации, в тексте сообщений запроса чата и не распознаёт никаких типов сущностей, — а также period-budget: tokens, подсчитывающее вместе токены prompt и completion, о которых сообщает каждый ответ, ничего не оценивая в деньгах. core/gateway/azure-api-management несёт period-budget: tokens, подсчитывающее вместе токены prompt и completion, о которых сообщает каждый ответ, с отдельным подсчётом на каждом шлюзе экземпляра, ничего не оценивая в деньгах. core/security/nemo-guardrails и core/security/trustyai-guardrails-gateway, два защитника, стоящие на пути модели и оценивающие запрос обученным классификатором, несут prompt-guard: classifier, которое выбирают сокеты guard AI-шлюза и шлюза NGINX. AI-шлюзы среди них — core/gateway/litellm, core/gateway/cloudflare-ai-gateway, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/kong-enterprise, core/gateway/traefik-hub, core/gateway/agentgateway, core/gateway/higress и core/gateway/azure-api-management — несут semantic, а остальные не несут никакого значения gateway.aggrega.ai/intelligence, и это работающее разделение, а не исключение из него: сущность Feature, которой нужно зеркалирование, охватывает три компонента, обладающие им, тогда как селектор уровня продукта охватил бы среди них только Envoy Gateway, по причине, которая ничего не говорит о зеркалировании, а сущность Feature, которой нужны защита prompt, маскирование содержимого или бюджет за период, охватывает AI-шлюз по тому, что он может делать, а не по уровню, на котором он находится, тогда как та, что ограничивает выполняющиеся запросы, охватывает шлюз NGINX, не несущий значения уровня, так же как охватывает Envoy Gateway и AI-шлюз, а та, что отклоняет запрос по списку шаблонов, охватывает Kong с открытым исходным кодом, который тоже его не несёт, так же как охватывает APISIX. Компонент, которому нечего описать на одной из этих осей, не несёт там никакого значения вместо самого слабого, поэтому селектор, называющий любое значение на этой оси, правильно к нему не присоединяется.

12. security.aggrega.ai/text-anonymization

  • Кто её записывает? Архитектор платформы, на сервисе, участвующем в маскировании чувствительного текста. Там, где эта работа разделена между двумя сервисами, analyzer ставится на тот, что находит чувствительные фрагменты в тексте и сообщает о них, а anonymizer — на тот, что переписывает переданные ему фрагменты; sanitizer ставится на сервис, делающий и то и другое за один вызов: он находит чувствительные фрагменты в присланном ему тексте, сам их переписывает и отвечает переписанным текстом.
  • Кто её использует? Статический анализатор, через селектор usesSchema сокета.
  • Сценарий использования в компиляторе: так потребитель получает правильный адрес. core/gateway/litellm объявляет сокет pii_analyzer, выбирающий security.aggrega.ai/text-anonymization=analyzer, и сокет pii_anonymizer, выбирающий значение anonymizer, поэтому подключение любого из этих сервисов к сокету другого останавливает сборку с нарушением селектора, в котором назван сокет. core/gateway/kong-enterprise объявляет один сокет, pii_sanitizer, выбирающий значение sanitizer, а core/gateway/traefik-hub — один, pii_analyzer, выбирающий только значение analyzer, поскольку Content Guard, который его Recipe для chart записывает для core/data-masking, сам заменяет то, что находит анализатор. Компилятор маршрутизирует адрес, который публикует выбранный компонент, и ничего не проверяет в отношении того, что по нему отвечает.
  • Что содержит стандартная библиотека. core/security/presidio-analyzer несёт analyzer, а core/security/presidio-anonymizer — anonymizer. Оба поддерживают HTTP API Presidio, который вызывает AI-шлюз, когда присоединение core/data-masking или собственное значение values.log_masking шлюза перечисляет типы сущностей, а Content Guard в Traefik Hub вызывает только анализатор, когда их перечисляет присоединение core/data-masking на этом шлюзе. core/security/kong-ai-pii-service несёт sanitizer и поддерживает API сервиса AI PII от Kong, который AI PII Sanitizer в Kong Gateway Enterprise вызывает с каждым маскируемым текстом, включая свои регулярные выражения, пока на этом шлюзе есть присоединение core/data-masking. Sanitizer не предъявляет ему никаких учётных данных, и каждый текст поступает к нему незамаскированным, поэтому его адрес является внутрикластерным и не предназначен для открытия за пределы кластера.

13. model.aggrega.ai/api

  • Кто это записывает? Platform Architect — на каждом компоненте категории model и на шлюзе, обслуживающем API моделей. Значение указывает, какой API моделей отвечает по адресу, который публикует компонент: openai, если это API OpenAI — собственный API поставщика или его реализация в сервере, — anthropic, если это Messages API от Anthropic, gemini, если это Gemini API от Google, и native, если это собственный API продукта и ни один из перечисленных, к которому потребитель обращается через клиент этого продукта. Каждое значение берётся из собственной справочной документации продукта, и компонент несёт его независимо от того, что настраивает конкретная сущность Release.
  • Кто это использует? Static Analyzer — через селектор usesSchema сокета, а также утверждения AI-шлюза, core/gateway/kong, core/gateway/kong-enterprise, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/traefik-hub, core/gateway/agentgateway и core/gateway/higress для каждого соединения с их сокетами models.
  • Сценарий использования в компиляторе: именно это позволяет одному сокету принимать либо модель, либо шлюз, обслуживающий модели. Сокет model каждого агента, кроме пяти сред выполнения, названных ниже, сокет target_model компонента core/ai-tool/model-invocation и два сокета моделей компонента core/datastore/cognee выбирают component.aggrega.ai/category in (ai-model, gateway), model.aggrega.ai/api: требование категории допускает обе категории, а требование ключа допускает из их компонентов только те, что несут эту метку, поэтому подключение такого сокета к шлюзу, не обслуживающему никакого API моделей, останавливает сборку с нарушением селектора, в котором назван сокет. Все требования селектора должны выполняться, а его альтернативы находятся внутри множества одного ключа, поэтому единственный ключ, на который отвечают оба вида компонентов, должен находиться на каждом компоненте модели так же, как и на шлюзе, — именно поэтому метка называет API, а не помечает только шлюзы. Шлюз, несущий её, публикует ключи endpoint и model, которые публикует модель, так что Recipe потребителя читает любой из них одинаково. Агент, чьи Recipes поставляют переменные одного API моделей, вместо этого называет его значение: сокеты model компонентов core/ai-agent/openai-agents-sdk, core/ai-agent/agent-framework и core/ai-agent/mastra выбирают model.aggrega.ai/api=openai, сокет core/ai-agent/claude-agent-sdk выбирает model.aggrega.ai/api=anthropic, а сокет core/ai-agent/google-adk выбирает model.aggrega.ai/api=gemini, поэтому подключение одного из них к модели или шлюзу, обслуживающему другой API, останавливает сборку с нарушением селектора, в котором назван сокет. Сокет core/ai-agent/google-adk также сужает категорию до ai-model, отклоняя любой шлюз, поскольку клиент ADK не читает никакого адреса и отправил бы учётные данные шлюза на собственный адрес Google. AI-шлюз читает значение, а не выбирает по нему: его сокет models выбирает component.aggrega.ai/category=ai-model, допуская любую модель, и поскольку шлюз описывает подключённую к нему модель своему прокси только через API OpenAI, утверждение его сущности Component останавливает сборку на соединении, цель которого несёт любое значение, кроме openai, называя соединение и указывая вместо этого вписать этот upstream в написанную вручную карту моделей шлюза. core/gateway/kong, core/gateway/kong-enterprise, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/traefik-hub, core/gateway/agentgateway и core/gateway/higress читают его так же на собственных сокетах models, поскольку каждый из них записывает маршрут подключённой модели, а в agentgateway — её запись модели, только для API OpenAI. Компилятор рассматривает значение как непрозрачную строку и ничего не проверяет в отношении того, что отвечает по адресу.
  • Что содержит стандартная библиотека. core/gateway/litellm, core/gateway/kong, core/gateway/kong-enterprise, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/traefik-hub, core/gateway/agentgateway и core/gateway/higress несут openai, как и самостоятельно размещаемые серверы core/ai-model/vllm, ollama, docker-model-runner, tgi, tei, nvidia-nim и litellm, управляемые API core/ai-model/openai, openai-embedding и nvidia-api, а также брокер core/ai-model/openai-compatible, который направляют на сервис, поддерживающий этот API. core/ai-model/anthropic несёт anthropic, а core/ai-model/gemini несёт gemini. Каждый другой компонент модели несёт native.

14. tool.aggrega.ai/transport

  • Кто это записывает? Platform Architect — на инструменте, к которому потребитель обращается через транспорт, который он должен поддерживать. Значение называет этот транспорт.
  • Кто это использует? Static Analyzer — через сокет инструментов потребителя.
  • Сценарий использования в компиляторе: так потребитель получает только те инструменты, с которыми умеет взаимодействовать. Сокет инструментов выбирает component.aggrega.ai/category=ai-tool, tool.aggrega.ai/transport=http: требование категории допускает инструменты и ничего больше, а требование транспорта допускает только инструменты, доступные по HTTP, поэтому подключение такого сокета к инструменту, не несущему такой метки, останавливает сборку с нарушением селектора, в котором назван сокет. Способ доступа к инструменту должен быть меткой, а не публикуемым значением, поскольку селектор читает метки и никогда не читает содержимое значения. Компилятор рассматривает значение как непрозрачную строку и ничего не проверяет в отношении того, что отвечает по адресу.
  • Что содержит стандартная библиотека. core/ai-tool/mcp несёт http. Он присоединяет сервер Model Context Protocol к агенту, а сущность Manifest выбирает, как этот сервер реализуется: helm/mcp и compose/mcp запускают образ, обслуживающий протокол по HTTP; helm/mcp-stdio-bridge и compose/mcp-stdio-bridge запускают пакет, поддерживающий только stdio, за закреплённым мостом, который обслуживает его по HTTP; helm/mcp-remote и compose/mcp-remote обращаются к серверу, который эксплуатирует кто-то другой, и ничего не запускают. Каждая реализация публикует одни и те же host, port, endpoint, protocol и credential_header, так что подключение потребителя не меняется вместе с реализацией. Собственные учётные данные сервера — это переменные окружения, хранящиеся в слоте server_env инструмента: на Kubernetes они передаются мосту по ссылке, а на Docker Compose записываются в окружение сервиса в переданном виде, где ссылка на переменную Compose держит учётные данные вне файла; учётные данные удалённого сервера хранит потребитель в собственном соединении с инструментом и предъявляет их в заголовке, который называет credential_header, — Authorization, если сущность Release не называет другой. Если удалённый сервер читает свой ключ из собственного адреса, потребитель также хранит весь адрес в этом соединении, в слоте endpoint, который на Kubernetes заполняется ссылкой на Secret, а на Docker Compose — ссылкой на переменную Compose, так что ключ не попадает ни в один отрендеренный файл, тогда как infra.endpoint инструмента содержит адрес без части, несущей ключ; examples/mcp-address-from-secret собирает оба варианта. core/ai-agent/openai-agents-sdk, core/ai-agent/claude-agent-sdk, core/ai-agent/agent-framework, core/ai-agent/google-adk и core/ai-agent/mastra, а также платформы потоков core/ai-agent/flowise и core/ai-agent/n8n объявляют сокет инструментов такого вида, tools, и передают адрес каждого подключённого инструмента, а учётные данные соединения — по ссылке, в переменных, названных по псевдониму соединения, тогда как соединение, в котором записан блок inject:, получает то, что предписывает этот блок, вместо переменных, выведенных из того, что публикует инструмент, а содержимое его слотов credential и endpoint остаётся под именем псевдонима; собственный потребитель объявляет такой сокет так же. Каждая из трёх платформ потоков при развёртывании переносит в платформу поток, созданный в сущности Aggregate, на обеих целях: Langflow загружает перенесённое определение из своего каталога потоков при каждом запуске, chatflow Flowise инициализируется одноразовым шагом, входящим под учётной записью владельца, названной сущностью Release, а workflow n8n импортируется шагом init перед запуском платформы. core/ai-agent/langflow объявляет сокет tools того же вида, который не допускает блока inject:, и вместо этого передаёт каждое соединение через этот поток, поскольку компонент MCP Tools в Langflow берёт адрес сервера только из собственных настроек Langflow или из потока, никогда — из переменной: его Recipes записывают адрес инструмента в узел MCP Tools, сервер которого назван по псевдониму соединения, передают учётные данные соединения по ссылке как переменную, которую называет заголовок этого узла, — в Authorization переменную, содержащую Bearer и учётные данные, — и пропускают хосты подключённых инструментов и хранилищ через защиту Langflow от частных адресов. Все три платформы также объявляют сокет vector_store, выбирающий datastore.aggrega.ai/engine in (vector, semantic-memory, search), который так же передаёт адрес каждого подключённого хранилища — публикуемый им endpoint, для core/datastore/pgvector URI подключения без пароля, или адрес, составленный из его протокола, хоста и порта, — а учётные данные соединения по ссылке; хранилище, которое также публикует свою базу данных и пользователя, как это делает core/datastore/pgvector, поступает в Flowise и n8n и этими частями, поскольку ни один из векторных узлов PostgreSQL этих двух платформ не принимает строку подключения; Langflow, чей компонент PGVector принимает одну строку, получает такое хранилище как AGGREGA_VECTOR_STORE_<ALIAS>_CONNECTION_STRING с учётными данными соединения в качестве пароля — по ссылке на Kubernetes и в переданном виде на Docker Compose. Chatflow Flowise читает переданную переменную через одноимённую переменную Runtime, созданную на странице Variables во Flowise, а workflow n8n читает её через $env только там, где сущность Aggregate задаёт значение allow_env_access_in_nodes платформы, поскольку по умолчанию её Recipes сохраняют блокировку n8n на доступ к окружению в узлах.

2. Абстракция портов (соглашение о нуле портов)

Каталог стандартной библиотеки Aggrega с открытым исходным кодом рекомендует не указывать объявления физических портов в когнитивном слое Components, а вместо этого направлять выбор порта через Recipe для Ops. Авторы, следующие этой рекомендации, избегают конфликтов портов между целями развёртывания, предотвращают появление API-бэкдоров, обходящих Injection Contract, и сохраняют гибкость сетевой топографии между поставщиками. Сам компилятор агностичен по отношению к портам — он передаёт любые значения, которые допускает разрешённая JSON Schema. Соглашение предусматривает явный запасной выход для унаследованных систем, физические порты которых нельзя изменить.

  • Cloud-native по умолчанию (динамическое внедрение): для современных рабочих нагрузок Components полностью опускают физические порты (никаких массивов ports или expose) в своём объявлении schema:. Recipes от Platform Ops выбирают внутренний порт TCP/UDP и публикуют его как именованный ключ provides, который нижестоящие потребители читают через Injection Contract .context.uses.
  • Запасной выход для унаследованных систем (явное объявление): когда у унаследованного компонента есть неизменяемый, жёстко заданный в коде порт, Platform Architect явно открывает поле port в объявлении schema: сущности Component. Это даёт роли Developer проверенный способ объявить физическое ограничение. Компилятор переносит значение через конвейер без изменений; Recipe использует его через {{ .values.port }}.
  • Операционные порты (вне полосы): порты, используемые исключительно инфраструктурой кластера (например, сбор метрик Prometheus, метрики сайдкаров Envoy), остаются скрытыми от когнитивного слоя роли Developer. Platform Ops внедряет их вне полосы через Features (например, присоединяя сущность Feature core/prometheus-exporter, порт сбора метрик которой задаётся оператором в infra).

3. Предметно-ориентированные схемы (интеллект конфигурации)

Блоки values разработчика (непрозрачные для компилятора Go, но строго типизированные объявлением schema: сущности Component) проверяются так, чтобы поддерживать явные рабочие процессы ИИ:

  • Связи агентов (массивы зависимостей): общая схема параметров агентов в стандартной библиотеке содержит tools_allowed и agents_allowed как массивы values, называющие Components каталога, которые агент может вызывать или которым может делегировать, — это задокументированное соглашение, которое компилятор не вычисляет. Связь, которую компилятор подключает как топологическое ребро, — это сокет uses, который Component агента объявляет в своём usesSchema, и именно селектор этого сокета проверяет сборка.
  • Глубокое разбиение когнитивной памяти (CoALA): вместо одного плоского сегмента памяти архитектор может объявить сокет cognitive_memory, соединения которого сопоставляют семантическую, эпизодическую и процедурную память с отдельными инфраструктурными целями в виде явных топологических рёбер, так что движки политик могут оценивать и предписывать детальные ограничения доступа (например, гарантировать, что агент может читать семантическую память, но не может перезаписать её в случае захвата). Стандартная библиотека не объявляет такого сокета.
  • Мультимодальные конвейеры: schema: сущности Component может объявлять явные этапы выполнения, такие как document_chunking, embedding_generation и storage_routing, как типизированные values, так что декларативный поток данных проверяется до того, как что-либо будет отрендерено. Стандартная библиотека не объявляет таких этапов.

4. Интеллект шлюзов и маршрутизация

AI-шлюзы стандартной библиотеки несут средства контроля для маршрутизации запросов к API LLM: core/gateway/litellm, работающий в кластере, и два размещённых сервиса — core/gateway/cloudflare-ai-gateway, размещённый шлюз Cloudflare, который его Recipe для terraform создаёт в учётной записи Cloudflare, и core/gateway/azure-api-management, AI-шлюз Azure API Management, чей Recipe для terraform добавляет API, обслуживающий модель, вместе с его бэкендом и политикой, к уже существующему экземпляру API Management. Recipes для helm и compose каждого размещённого шлюза ссылаются на него там, где он уже настроен. Некоторые средства контроля — это значения на самом шлюзе, а некоторые — присоединённые к нему Features, и каждая сущность Feature ниже указывает, на каком шлюзе её реализует стандартная библиотека. На размещённом шлюзе каждое средство контроля записывается в собственную конфигурацию шлюза — как параметр ресурса шлюза Cloudflare или элемент политики API в Azure API Management, — поэтому только его Recipe для terraform может нести такое средство, а его Recipes для helm и compose останавливают сборку на любом присоединении. Ниже «AI-шлюз» — это core/gateway/litellm, «размещённый шлюз» — core/gateway/cloudflare-ai-gateway, а шлюз Azure API Management назван полностью.

Вне Aggrega, во время выполнения

агент

его сокет model, подключённый к шлюзу

ИИ-шлюз

с подключёнными к нему средствами контроля

бюджет токенов

семантический кэш

защита от инъекций в промпт

модель

провайдер за шлюзом

Запросы агента проходят через шлюз, к которому подключён его сокет model, поэтому каждое средство контроля, подключённое к шлюзу, стоит между агентом и моделью. Три показанных здесь — это сущности Features core/period-budget, core/semantic-caching и core/prompt-injection-shield, изображённые рядом, чтобы показать, где они находятся, а не как конфигурация одного шлюза: в пунктах ниже сказано, какой шлюз реализует каждое средство контроля и что останавливает сборку.

  • Модели за ним: карта моделей AI-шлюза — псевдонимы, которые он обслуживает, каждый с upstream, куда отправляется запрос к нему, — состоит из двух частей. Компонент модели, подключённый к сокету models шлюза, управляемый или самостоятельно размещённый, обслуживается под псевдонимом соединения, а его запись формируется из endpoint и model, которые публикует модель, — строк, которые компилятор передаёт в конфигурацию шлюза и никогда не разрешает; таким образом, модель является компонентом графа, доступным через собственное ребро. Шлюз описывает такую модель своему прокси только через API OpenAI, поэтому соединение с моделью, чей model.aggrega.ai/api не равен openai, останавливает сборку, называя соединение. Вторая часть — это values.models шлюза, записи, введённые вручную в собственной нотации прокси поставщик/модель: для upstream, который каталог не моделирует, для поставщика, чей собственный API не является API OpenAI, и для нескольких записей с общим псевдонимом, чего подключённые модели делать не могут, поскольку каждая обслуживается под псевдонимом собственного соединения. Подключённая запись предъявляет учётные данные, которые несёт её собственное соединение, как описано ниже в разделе «Ключ, который предъявляет вызывающий», и никогда — provider_key шлюза; каждая введённая вручную запись предъявляет единственные учётные данные из этого слота. Псевдоним, который публикуют обе части, останавливает сборку с его названием, как и шлюз, которому ни одна из частей не даёт модели.

  • На пути агента: шлюз публикует endpoint и model — ключи, которые публикует компонент модели, — и несёт model.aggrega.ai/api: openai, поэтому сокет model агента принимает шлюз напрямую, и каждое присоединённое к нему средство контроля стоит между этим агентом и поставщиками за ним. model, который он публикует, — это псевдоним, названный его values.model, и сборка останавливается, когда ни одна часть карты его не публикует; его можно опустить только там, где шлюз обслуживает один псевдоним и его публикует запись values.models, которая тогда и становится опубликованной. Вызывающий, которому нужен другой псевдоним, опубликованный картой, запрашивает его по имени у того же endpoint. core/gateway/cloudflare-ai-gateway публикует те же два ключа — адрес одного из endpoint шлюза, составленный из учётной записи Cloudflare и идентификатора шлюза, и модель, которую запрашивает вызывающий и которую шлюз пересылает без проверки, — но не несёт никакого model.aggrega.ai/api, поэтому сокет model агента его не принимает. core/gateway/azure-api-management также их публикует — адрес своего API, составленный из хоста экземпляра и пути API, и модель, которую запрашивает вызывающий, пересылаемую без проверки, — и также не несёт никакого model.aggrega.ai/api: API отвечает на запрос chat completions от OpenAI, но по умолчанию вызывающий предъявляет ключ подписки API Management в собственном заголовке вместо bearer-токена OpenAI, поэтому обычного клиента OpenAI недостаточно, чтобы его вызвать.

  • Kong перед моделями: core/gateway/kong, шлюз Kong с открытым исходным кодом, обслуживает модели, подключённые к его собственному сокету models, через AI Proxy от Kong и из приведённых ниже средств контроля реализует только шаблоны отклонения промптов — как AI Prompt Guard от Kong на каждом маршруте каждой подключённой модели. Каждая подключённая модель получает маршрут chat и маршрут completion под /<alias>/v1, сформированные из endpoint и model, которые публикует модель, а его Recipes импортируют эти маршруты в бэкенд PostgreSQL шлюза до его запуска. Маршрут выбирает модель, поэтому запрос отправляется к модели, которую называет его путь, независимо от того, какое имя модели он содержит. Шлюз предъявляет собственные учётные данные каждого соединения как bearer-токен, который его конфигурация читает по имени из окружения шлюза, а соединение с моделью, чей model.aggrega.ai/api не равен openai, останавливает сборку. Он публикует маршрут псевдонима, названного его values.model, как свой endpoint, а этот псевдоним — как свой model, и несёт model.aggrega.ai/api: openai, поэтому сокет model агента принимает его так же, как AI-шлюз. Если к этому сокету ничего не подключено, шлюз не обслуживает ни одной модели и публикует оба ключа пустыми, и подключённый к нему агент тогда не читает ни адреса, ни имени модели. Импорт добавляет и обновляет маршруты, но не удаляет ни одного, поэтому маршрут, соединение которого удалено, продолжает отвечать, а защита промптов, записанная присоединением core/prompt-deny-patterns, продолжает отклонять запросы после удаления присоединения, пока каждый из них не будет удалён через Admin API от Kong. По той же причине шлюз не объявляет вызывающих, и его маршруты моделей не проверяют ключ ни одного вызывающего: Kong различает вызывающих только как consumers, названных плагином аутентификации, а consumer и его ключ, однажды импортированные, оставались бы способными аутентифицироваться после удаления вызывающего из сущности Release, а ротированный ключ оставлял бы старый рабочим; кроме того, ключ key-auth нельзя хранить по ссылке, поэтому ключ вызывающего мог бы попасть в Kong только как литерал в отрендеренном файле.

  • Kong Gateway Enterprise перед моделями: core/gateway/kong-enterprise, платная редакция Kong того же шлюза с базой данных, обслуживает модели, подключённые к его собственному сокету models, на маршрутах, которые обслуживает core/gateway/kong, записанных из той же конфигурации и импортированных в его бэкенд PostgreSQL шагом в собственном поде шлюза до запуска шлюза, и публикует свои endpoint и model так же, как Kong. Его единственная реализация — Recipe типа chart на основе официального Helm-чарта Kong; реализации compose нет. Он запускает образ, который сущность Release указывает в infra.image, включая тег версии, поскольку Kong распространяет enterprise-образ на собственных условиях и поэтому каталог не указывает никакого; сборка останавливается, пока этот ключ не задан или его тег не содержит версии. Лицензия попадает в шлюз по ссылке на Secret, привязанный к его обязательному слоту license, никогда как значение, и сборка останавливается, пока ничто не привязывает этот слот. Компилятор не проверяет никакую лицензию и не обращается ни к какому поставщику, поэтому сущность Release, которая собирается без ошибок, ничего не говорит о лицензии: Kong считывает лицензию при запуске узла, а узел без действительной лицензии ведёт себя как с истёкшей — конфигурация его сущностей доступна только для чтения, а трафик прокси обслуживается с уже действующей конфигурацией. Kong продаёт свои AI-плагины как предложение AI Gateway Enterprise — право, входящее в лицензию, которое ни одна сборка не видит, — и пропускает такой плагин вместо того, чтобы отклонить его, там, где лицензия этого права не содержит, поэтому присоединение core/semantic-caching, core/period-budget, core/data-masking, core/fallback-chain, core/retry-policy или core/target-selection останавливает сборку, пока сущность Release не установит infra.ai_gateway_entitled в true, подтверждая, что лицензия это право содержит. Из описанных ниже средств контроля он реализует бюджет на период и цепочку fallback, каждое из которых записывается в маршруты, импортируемые шлюзом, а core/data-masking реализует так, как описано ниже в разделе «Утечка данных и перехват полезной нагрузки»; его реализации семантического кеша, политики повторных попыток и выбора цели останавливают любое присоединение, каждая с указанием причины, а ограничение параллелизма, журналирование аудита, проверка на prompt injection, проверка ответов и шаблоны запрета промптов не имеют там реализации, поэтому присоединение любого из них останавливает сборку. Изменённый набор маршрутов вызывает поэтапное повторное развёртывание шлюза, а импорт добавляет и обновляет маршруты, не удаляя ни одного, поэтому маршрут, соединение которого удалено, и плагин, записанный сущностью Feature для AI, после удаления сущности Feature остаются в базе данных, пока их не удалят через Admin API Kong; по причинам, приведённым в пункте выше, он также не объявляет вызывающих, и его маршруты моделей не проверяют ключ ни одного вызывающего. То, что работающий шлюз применяет какое-либо из этих средств контроля, не наблюдается ни одной сборкой.

  • APISIX перед моделями: core/gateway/apisix, шлюз Apache APISIX с открытым исходным кодом, обслуживает модели, подключённые к его собственному сокету models, через AI-прокси APISIX там, где сущность Manifest привязывает его Recipe типа chart, запускающую APISIX 3.18.0. Каждая подключённая модель получает маршрут chat и маршрут completion под /<alias>/v1 — только маршрут chat, пока присоединены бюджет на период или шаблоны запрета промптов, поскольку APISIX не считает токены в запросе completion, а его prompt guard его не читает, — записанные из endpoint и model, которые публикует модель, в файл маршрутов, рендерящийся вместе со шлюзом, который шлюз считывает при запуске и снова при каждом изменении файла. Шлюз, считывающий свои маршруты из этого файла, не читает никакой etcd и не запускает никакого Admin API, поэтому при подключённой модели соединение etcd или присоединение admin_key останавливает сборку, а когда ничего не подключено, оба обязательны. Маршрут выбирает модель. Шлюз предъявляет собственные учётные данные каждого соединения как bearer-токен, который его маршруты считывают по имени из окружения шлюза, а соединение с моделью, у которой model.aggrega.ai/api не равно openai, останавливает сборку. Он публикует маршрут псевдонима, указанного в его values.model, как свой endpoint, а этот псевдоним — как свой model, и несёт model.aggrega.ai/api: openai, поэтому сокет model агента принимает его так же, как AI-шлюз; когда ничего не подключено, он публикует оба ключа пустыми. Маршрут, соединение которого удалено, исчезает из следующего рендеринга. Сущность Release может указать вызывающих шлюза в infra.callers, а их ключи — через слот caller_keys, Secret, содержащий по одному ключу данных на имя вызывающего: каждый вызывающий тогда является потребителем в файле маршрутов, ключ которого считывается по имени из этого Secret, и каждый маршрут отклоняет с HTTP 401 запрос, не предъявляющий ни одного объявленного ключа как Authorization: Bearer <key> — так, как его предъявляет клиент OpenAI, — и удаляет ключ из пересылаемого запроса. Без вызывающих маршруты открыты. Его Recipe типа workload, с APISIX 3.17.0, хранит маршруты в etcd, не рендерит ни одного и останавливает сборку при наличии соединения с этим сокетом и infra.callers. Из описанных ниже средств контроля он реализует бюджет на период, семантический кеш для объявленных им вызывающих и шаблоны запрета промптов.

  • Envoy Gateway перед моделями: core/gateway/envoy-gateway, Envoy Gateway с открытым исходным кодом, обслуживает модели, подключённые к его собственному сокету models, через Envoy AI Gateway, контроллер которого, core/gateway/envoy-ai-gateway-operator, шлюз вызывает как свой сервер расширений через свой сокет extension. Подключённая модель, когда к этому сокету ничего не подключено, останавливает сборку, а при подключённом контроллере сущность Release размещает шлюз в envoy-gateway-system, иначе сборка останавливается. Каждая подключённая модель становится правилом единственного AI-маршрута, присоединённого к шлюзу, выбираемым по имени модели, которое несёт запрос, с бэкендом, записанным из endpoint и model, которые публикует модель, поэтому каждая подключённая модель обслуживается под /v1 по собственному адресу шлюза. Шлюз предъявляет собственные учётные данные каждого соединения как bearer-токен, который контроллер Envoy AI Gateway считывает из Secret, указанного в учётных данных, а соединение с моделью, у которой model.aggrega.ai/api не равно openai, останавливает сборку. Пока модель подключена, каждый маршрут на шлюзе получает буфер запросов 50Mi на соединение, который настраивает Envoy AI Gateway. Он публикует свой адрес, уточнённый envoy-gateway-system, чтобы он разрешался из любого пространства имён, как свой endpoint, а псевдоним, указанный в его values.model, — как свой model, и несёт model.aggrega.ai/api: openai, поэтому сокет model агента принимает его так же, как AI-шлюз; когда ничего не подключено, он публикует оба ключа пустыми. Вебхук контроллера предъявляет сертификат, выпускаемый cert-manager, поэтому cert-manager уже должен работать в кластере, если только сущность Release не укажет в infra.webhook_tls_secret контроллера Secret с сертификатом, предоставленным оператором, который вебхук тогда и предъявляет. Из описанных ниже средств контроля он реализует бюджет на период, политику повторных попыток и ограничение параллелизма, каждое из которых записывается в единственную политику трафика маршрута, обслуживающего его модели. Он не реализует семантический кеш и проверку ответов, поскольку Envoy AI Gateway не хранит никакого ответа, которым можно было бы ответить на более поздний запрос, и не проверяет никакой ответ по схеме, а также цепочку fallback: Envoy AI Gateway выполняет fallback, повторяя попытку на других бэкендах правила модели, а шлюз записывает число повторных попыток своей единственной политики трафика в каждое правило маршрута, обслуживающего его модели, поэтому список fallback получил бы ровно свои отправки только там, где список каждой подключённой модели имеет одинаковую длину. Он реализует core/audit-logging как свой журнал доступа, как описано ниже в разделе «Журналирование аудита», и отклоняет по названию то, что этот журнал не может сохранить: стоимость запроса, поскольку стоимость на запрос, которую может вычислить Envoy AI Gateway, не имеет единицы, а шлюз не хранит цен; вызывающего, проверенного шлюзом, поскольку ничто на этом пути не проверяет вызывающего; и срок хранения, поскольку у этого журнала нет ни хранилища, ни настройки хранения. examples/envoy-ai-gateway-token-budget строит весь путь с агентом, обращающимся к управляемой модели OpenAI через шлюз.

  • agentgateway перед моделями: core/gateway/agentgateway, agentgateway с открытым исходным кодом, обслуживает модели, подключённые к его собственному сокету models, из одного конфигурационного файла, который рендерят его сущности Recipes. Каждая подключённая модель является записью этого файла, названной по псевдониму соединения и записанной из endpoint и model, которые публикует модель, как OpenAI-совместимый поставщик chat completions, поэтому каждая подключённая модель обслуживается под /v1 по собственному адресу шлюза, а выбирает её имя модели, которое несёт запрос: запрос доходит до модели, запрашивая имя модели, которое публикует модель, а на имя, которое не несёт ни одно соединение, отвечают HTTP 404. Шлюз предъявляет собственные учётные данные каждого соединения как bearer-токен, который файл указывает как переменную, считываемую шлюзом из своего окружения при чтении файла, причём отсутствие там этой переменной не даёт ему запуститься, а соединение с моделью, у которой model.aggrega.ai/api не равно openai, останавливает сборку. Он публикует этот базовый URL /v1 как свой endpoint, а псевдоним, указанный в его values.model, — как свой model, и несёт model.aggrega.ai/api: openai, поэтому сокет model агента принимает его так же, как AI-шлюз; когда ничего не подключено, он публикует оба ключа пустыми. Две сущности Recipes запускают один и тот же образ, закреплённый по digest: agentgateway-chart рендерит автономный Helm-чарт проекта, получаемый из реестра проекта, и реализует описанные ниже средства контроля, а agentgateway запускает образ как одну службу Docker Compose и не реализует ни одного из них, как и вызывающих, поэтому присоединение там останавливает сборку с указанием своего типа; в Kubernetes, где сборка может обратиться к этому реестру, следует выбирать чарт. В чарте сущность Release может указать вызывающих шлюза в infra.callers, а их ключи — через слот caller_keys, как и в APISIX: каждый вызывающий является API-ключом файла, проверяемым в строгом режиме и считываемым по имени из этого Secret, поэтому запрос к модели, не предъявляющий ни одного объявленного ключа как Authorization: Bearer <key>, отклоняется с HTTP 401, а ключ удаляется из пересылаемого запроса; без вызывающих маршруты моделей открыты. agentgateway подставляет каждый ключ, который файл указывает таким образом, — ключ подключённой модели в любой из сущностей Recipe и ключ вызывающего в чарте — в текст файла, прежде чем прочитать файл как YAML, поэтому ключ должен быть простым токеном — буквы, цифры и -, ., _, ~, +, / и =, — а другие символы могут загрузиться как другой ключ или остановить шлюз. Шлюз перечитывает свой файл при его изменении, поэтому вызывающий, удалённый из сущности Release, отклоняется, как только смонтированный файл обновлён. Пока присоединено core/audit-logging или core/period-budget с областью caller, Recipe типа chart предоставляет шлюзу хранилище — файл SQLite на отдельном томе — и запускает одну реплику. Из описанных ниже средств контроля он реализует маскирование данных, шаблоны запрета промптов, бюджет на период, журналирование аудита и политику повторных попыток, каждое из которых записывается в файл, и отклоняет по названию каждое значение, которое не может соблюсти. Маскирование данных заменяет каждое совпадение шаблонов, перечисленных в присоединении, на <masked> или в режиме refuse отвечает на запрос или ответ кодом HTTP 403 — в системных промптах и промптах разработчика запроса, его остальных сообщениях, аргументах и результатах его вызовов инструментов, а также в тексте сообщения ответа, поступающего целиком; оно не распознаёт типов сущностей и ничего не восстанавливает. agentgateway не маскирует потоковый ответ, поэтому, пока ответы маскируются, запрос к модели, запрашивающий потоковый ответ, отклоняется с HTTP 403 до пересылки, как и любой запрос к модели, тело которого больше 2 MiB, считываемых шлюзом для этой проверки, потоковый или нет. Отказ со стороны защитного механизма, в том числе шаблона запрета, — это HTTP 403 с телом «The request was rejected due to inappropriate content» (Запрос отклонён из-за недопустимого содержимого). Бюджет, записи и повторные попытки описаны ниже в разделах «Бюджет на период», «Журналирование аудита» и «Отказоустойчивость». Его реализации цепочки fallback, выбора цели, семантического кеша, проверки ответов и проверки на prompt injection останавливают любое присоединение, каждая с указанием причины, а ограничение параллелизма к нему не присоединяется, поскольку он не несёт значения dataplane.aggrega.ai/concurrency-cap.

  • Traefik Hub перед моделями: core/gateway/traefik-hub, платный шлюз Traefik, обслуживает модели, подключённые к его собственному сокету models, через промежуточное ПО Chat Completion в Traefik Hub. Его единственная реализация — Recipe типа chart на основе собственного Helm-чарта Traefik; реализации compose нет. Он запускает образ, который сущность Release указывает в infra.image, включая тег, поскольку Traefik распространяет Traefik Hub на собственных условиях и поэтому каталог не указывает никакого; сборка останавливается, пока этот ключ не задан или не указывает тег. Лицензионный токен попадает в шлюз по ссылке на Secret, привязанный к его обязательному слоту license, под ключом данных token, никогда как значение, и сборка останавливается, пока ничто не привязывает этот слот или он публикует другой ключ данных. Traefik требует исходящего HTTPS к api.traefik.io, где шлюз проверяет свой токен; начиная с Traefik Hub v3.21 шлюз продолжает обслуживать, пока этот хост недоступен, повторяя попытки в фоновом режиме, а токен по умолчанию действует год, и шлюз останавливается, как только срок его действия истекает. Recipe типа chart отключает экспорт чартом журналов ошибок шлюза на платформу Traefik и его проверку наличия более новой версии. Компилятор не проверяет никакой токен и не обращается ни к какому поставщику, поэтому сущность Release, которая собирается без ошибок, ничего не говорит о том, запустится ли шлюз. Каждая подключённая модель получает маршрут по адресу /<alias>/v1/chat/completions, отправляемый на endpoint, который публикует модель, через Service типа ExternalName и запрашивающий model, который она публикует, независимо от имени модели, которое несёт запрос, поэтому модель определяется путём; он обслуживает только chat completions. Шлюз предъявляет собственные учётные данные каждого соединения как bearer-токен, который Traefik Hub считывает из Secret, указанного в промежуточном ПО Chat Completion соединения, а соединение с моделью, у которой model.aggrega.ai/api не равно openai или конечная точка указывает адрес вместо хоста, останавливает сборку. Он публикует маршрут псевдонима, указанного в его values.model, как свой endpoint, а этот псевдоним — как свой model, и несёт model.aggrega.ai/api: openai, поэтому сокет model агента принимает его так же, как AI-шлюз; когда ничего не подключено, он публикует оба ключа пустыми. Сущность Release может указать вызывающих шлюза в infra.callers, а htpasswd-хеши их ключей — через слот caller_keys: промежуточное ПО API Key в Traefik Hub тогда стоит в начале каждого маршрута модели и отклоняет запрос, не предъявляющий ни одного объявленного ключа как Authorization: Bearer <key>, а ключ удаляется из пересылаемого запроса; без вызывающих маршруты открыты. Что Traefik Hub делает с записью вызывающего, указывающей несуществующий Secret или ключ данных, в его справочнике не указано, поэтому в худшем случае маршруты так же открыты, как без вызывающих. Из описанных ниже средств контроля он реализует бюджет на период, семантический кеш для объявленных им вызывающих, шаблоны запрета промптов и маскирование данных — через промежуточное ПО AI-шлюза Traefik Hub, — а также цепочку fallback и политику повторных попыток — через собственные failover и повторные попытки Traefik, — каждое из которых записывается в маршруты, которые рендерит его Recipe типа chart. AI-шлюз — это право, входящее в лицензию, которое ни одна сборка не видит, а то, что Traefik Hub делает с действительным токеном, лицензия которого этого права не содержит, не задокументировано, поэтому присоединение любого из первых четырёх останавливает сборку, пока сущность Release не установит infra.ai_gateway_entitled в true. Его реализации проверки на prompt injection, журналирования аудита, выбора цели и проверки ответов останавливают любое присоединение, каждая с указанием причины, а ограничение параллелизма к нему не присоединяется, поскольку он не несёт значения dataplane.aggrega.ai/concurrency-cap. То, что работающий шлюз применяет какое-либо из этих средств контроля, не наблюдается ни одной сборкой.

  • Higress перед моделями: core/gateway/higress, шлюз Higress с открытым исходным кодом, построенный на Envoy и настраиваемый через ресурсы Kubernetes, обслуживает модели, подключённые к его собственному сокету models, через AI proxy Higress. Его единственная реализация — сущность Recipe типа chart поверх собственного Helm-чарта проекта higress-core, который запускает контроллер Higress вместе с его службой обнаружения и шлюз; реализации compose нет, поскольку проект предназначает свой дистрибутив compose в основном для локального тестирования, а этот дистрибутив запускает несколько взаимодействующих служб, настраиваемых через собственное хранилище. Сущность Recipe фиксирует чарт, образы и каждый модуль плагина, который она записывает, и принимает в infra.source_version только те версии чарта, для которых её конфигурация проверена; шлюз загружает эти модули из реестра плагинов Higress во время выполнения, поэтому кластер должен иметь к нему доступ, а сборка не может это проверить. Контроллер отслеживает только пространство имён сущности Release, под IngressClass, названным по шлюзу и этому пространству имён, поэтому два шлюза Higress в одном пространстве имён конфликтуют. Каждый псевдоним получает маршрут по адресу /<alias>/v1, который отправляется на endpoint, публикуемый моделью псевдонима, через запись собственного реестра шлюза и запрашивает публикуемую ею model независимо от имени модели в запросе, так что модель выбирает путь; соединения, называющие один псевдоним в своём значении serves, делят его запросы поровну. Шлюз предъявляет собственные учётные данные каждого соединения как bearer token, который контроллер Higress считывает из объекта Secret, названного в конфигурации AI proxy, в пространстве имён шлюза, и передаёт шлюзу, поэтому ключ не попадает ни в один отрисованный файл; имя Secret, содержащее точку, останавливает сборку, поскольку Higress читает имя только до первой точки, а соединение без учётных данных передаёт дальше ключ, который предъявляет запрос. AI proxy Higress также копирует заголовок Authorization, отправленный клиентом, в заголовок X-HI-ORIGINAL-AUTH, и каждый маршрут модели удаляет эту копию до того, как запрос достигнет модели, поэтому ключ, предъявленный клиентом, никогда не передаётся рядом с собственными учётными данными соединения. По https шлюз проверяет, что сертификат модели восходит к якорям доверия системы и называет хост модели, независимо от того, какой хост отправил клиент, а иначе ничего модели не отправляет: сущность Recipe помечает маршрут каждого псевдонима, все соединения которого используют https, аннотацией Higress higress.io/backend-protocol: HTTPS, так что шлюз берёт имя сервера из хоста, который AI proxy записывает в каждый запрос, — хоста модели, дополненного пространством имён модели там, где он не содержит точки, — и проверяет сертификат по нему. Эта аннотация применяется к каждому соединению псевдонима, поэтому псевдоним, смешивающий соединения http и https, останавливает сборку, называя оба; обслуживание их под двумя псевдонимами устраняет это. Соединение с моделью, чей model.aggrega.ai/api не равен openai или чья конечная точка указывает адрес вместо хоста, останавливает сборку. Шлюз публикует маршрут псевдонима, названного его values.model, как свой endpoint, а этот псевдоним — как свою model, и несёт model.aggrega.ai/api: openai, поэтому сокет model агента принимает его так же, как принимает AI-шлюз; когда ничего не подключено, он публикует оба ключа пустыми. Он не объявляет вызывающих, поэтому его маршруты моделей не проверяют ключ ни одного вызывающего, а значение, требующее вызывающего, проверенного шлюзом, отклоняется с указанием имени. Из описанных ниже средств контроля он реализует бюджет на период, журналирование аудита и политику повторных попыток, каждое из которых записано на маршруты моделей, а core/data-masking реализует так, как описывает ниже раздел «Эксфильтрация данных и перехват полезной нагрузки». Его реализации проверки ответов, цепочки резервирования, семантического кеша, выявления prompt injection и выбора цели останавливают каждое присоединение, каждая с указанием причины, а ни шаблоны блокировки промптов, ни ограничение параллелизма к нему не присоединяются, поскольку он не несёт ни значения dataplane.aggrega.ai/prompt-guard, ни значения dataplane.aggrega.ai/concurrency-cap. То, что работающий шлюз применяет какое-либо из этих средств контроля, ни одна сборка не наблюдает.

  • Azure API Management перед моделью: core/gateway/azure-api-management, AI-шлюз Azure API Management, размещённой службы, обслуживает один API модели через API на уже существующем экземпляре API Management. Его сущность Recipe типа terraform считывает экземпляр и добавляет API, его операцию chat completions, бэкенд, на который он пересылает, и политику API, которая удаляет ключ подписки вызывающего из пересылаемого и аутентифицируется перед API модели так, как указывает infra.backend_authentication: управляемым удостоверением экземпляра, ключом поставщика, хранящимся в Key Vault, или без аутентификации. Его сущности Recipes типов helm и compose ссылаются на API, настроенный вне сущности Release, и останавливают сборку при любом присоединении. Из описанных ниже средств контроля его сущность Recipe типа terraform реализует семантический кеш, бюджет на период, выявление prompt injection и политику повторных попыток, каждое из которых записано в политику API. Он не реализует ограничение параллелизма, поскольку Microsoft называет предел, применяемый её политикой параллелизма, никогда не вполне точным и более низким, когда в регионе работает несколько единиц ёмкости, и не реализует цепочку резервирования, поскольку API пересылает на один бэкенд, а собственное резервирование Azure, группы приоритетов пула бэкендов, уводит последующие запросы от бэкенда, чей автоматический выключатель сработал, вместо того чтобы отправить неудавшийся запрос другой модели. Его реализация core/audit-logging останавливает каждое присоединение, называя то, что вне её досягаемости: сам журнал, который включает параметр диагностики на экземпляре; стоимость запроса, пока включено require_cost, поскольку журнал запросов к моделям Azure записывает количество токенов и модель, но не цену; и срок хранения, если задано retention_days, поскольку строка хранится столько, сколько её хранит рабочая область Log Analytics, в которую она попадает. То, что политики применяются и соблюдаются так, как документирует Microsoft, ни одна сборка не наблюдает.

  • Ключ, который предъявляет вызывающий: Сервер, проверяющий ключ, который предъявляют его вызывающие, хранит этот ключ в собственном слоте, называемом api_key на каждой цели, обслуживающей модели и проверяющей ключ, — core/ai-model/vllm, tei и tgi, модели LiteLLM и AI-шлюзе, где это ключ, который LiteLLM называет своим главным ключом, — и каждая из его сущностей Recipes передаёт ключ как переменную, которую считывает сервер. core/gateway/apisix и core/gateway/agentgateway хранят по одному ключу для каждого вызывающего, которого их сущность Release называет в infra.callers, в своём слоте caller_keys: один Secret, содержащий ключ каждого вызывающего под его именем. core/gateway/traefik-hub хранит своих вызывающих так же, за исключением того, что его Secret содержит хеш htpasswd ключа каждого вызывающего, с которым его проверка ключей сравнивает предъявленный ключ, поэтому это не тот Secret, из которого вызывающий предъявляет свой ключ. Вызывающий хранит предъявляемый ключ на своей стороне, на соединении, на котором его предъявляет, в слоте, который объявляет его сокет: агенты стандартной библиотеки объявляют его на своём сокете model, credential; AI-шлюз — на своём сокете models и на сокете cache_store, где это пароль, который семантический кеш шлюза предъявляет своему хранилищу; core/gateway/kong и core/gateway/kong-enterprise — на своих сокетах models; core/gateway/apisix — на сокете models и на сокете cache_store, где это также пароль, который его семантический кеш предъявляет своему хранилищу; core/gateway/agentgateway — на сокете models; core/gateway/envoy-gateway — на сокете models и на сокете cache, где это пароль, который служба ограничения частоты запросов шлюза предъявляет хранилищу, ведущему счётчик бюджета на период; core/gateway/higress — на сокете models и на сокете cache, где это пароль, который его лимит токенов предъявляет хранилищу, ведущему счётчик бюджета на период; и core/gateway/traefik-hub — на сокете models, на сокете cache, где это пароль, который его квота предъявляет хранилищу, ведущему счётчик бюджета на период, и на сокете cache_store, где это пароль, который его семантический кеш предъявляет своему хранилищу, — так что агент, обращающийся к модели, или шлюз, обращающийся к обслуживаемой им модели, хранит там ключ этого соединения. AI-шлюз, оба Kong, APISIX и agentgateway передают ключ каждой подключённой модели как отдельную переменную, которую называет запись или маршрут этой модели в их конфигурации; Envoy Gateway называет Secret в политике безопасности бэкенда модели, и контроллер Envoy AI Gateway считывает из него ключ; Traefik Hub называет Secret и ключ данных в middleware Chat Completion маршрута модели и считывает из него ключ. Соединение с моделью с меткой component.aggrega.ai/hosting: managed несёт ключ или указывает в собственных values, что модель не принимает ключа, unauthenticated: true; если нет ни того, ни другого, утверждение вызывающего останавливает сборку, называя соединение и его цель, а модель с другой меткой такой остановки не вызывает. Ключ, который сущность Component вызывающего вместо этого объявляет в собственном слоте, является одним ключом для каждого устанавливаемого ею соединения. Ни один из концов не видит присоединений другого, поэтому сервер ничего не узнаёт о ключе вызывающего, а оба совпадают, потому что сущность Aggregate питает оба из одного параметра: там, где оба конца разрешают секреты в одной области — одном пространстве имён Kubernetes, одном проекте Compose, — они ссылаются на один секрет, а иначе каждый хранит собственный, реализованный из той же записи хранилища. vLLM, TEI и TGI проверяют каждый только один ключ, поэтому каждый вызывающий предъявляет один и тот же ключ и сервер не может различить своих вызывающих, а TGI сравнивает свой ключ без учёта регистра; APISIX, agentgateway и Traefik Hub проверяют каждый ключ каждого объявленного вызывающего и различают по нему своих вызывающих; оба Kong не объявляют вызывающих и не проверяют ключ ни одного вызывающего по причинам, приведённым выше в разделе «Kong перед моделями»; модель LiteLLM и AI-шлюз также принимают выдаваемые ими ключи, пока присоединена их база данных учёта. Модель учётных данных разбирает эту схему на примере одной сущности Aggregate.

  • Выбор между целями: core/target-selection объявляет, как шлюз выбирает между несколькими целями, способными обслужить один и тот же запрос, с помощью strategy со значением latency (цель, которая, по наблюдениям, отвечает быстрее всех) или cost (цель, вызов которой дешевле всего). Стратегия является частью того, что приложение требует от своего шлюза, поэтому её присоединяет разработчик в сущности Aggregate. На AI-шлюзе целями являются записи его values.models, публикующие один и тот же псевдоним, — подключённая модель обслуживается под псевдонимом своего соединения, который не может публиковать ни одна другая запись, — и стандартная библиотека реализует latency, записывая latency-based-routing прокси в конфигурацию маршрутизации, которую отрисовывает сущность Recipe шлюза: прокси отправляет каждый запрос записи, последние десять ответов которой заняли в среднем меньше всего времени, в пересчёте на выходной токен, если ответ сообщает свои токены, или до первого токена для потокового запроса, а ещё не опробованная запись считается самой быстрой. Без присоединения конфигурация не называет никакой стратегии, и прокси выбирает среди этих записей случайно. cost там отклоняется с указанием имени: прокси определяет цену записи, ища её цель, в точности как она записана, в таблице цен, которая называет модели OpenAI и Anthropic без префикса поставщика, который несут цели шлюза, а записи, которую не находит, назначает фиксированную резервную цену, так что записи с общим псевдонимом получили бы одинаковую цену и выбирались бы по порядку. На core/gateway/kong-enterprise каждое присоединение останавливает сборку, потому что каждая подключённая к нему модель обслуживается на собственных маршрутах, несущих только эту модель, и выбирать не из чего. На core/gateway/agentgateway каждое присоединение также останавливает сборку с указанием причины: agentgateway случайно выбирает две цели имени модели и берёт ту, чьё состояние работоспособности, делённое на время, затраченное на ответ, оценивается выше, поэтому самая быстрая цель берётся лишь тогда, когда она выбрана, и он не выбирает ни одной цели по стоимости. На core/gateway/higress каждое присоединение также останавливает сборку с указанием причины: Higress может измерять задержку службы, но его плагин балансировки нагрузки выполняется после AI proxy — который уже установил модель, адрес и учётные данные запроса для кандидата, определённого маршрутом, — и записывает свой выбор в заголовок запроса, по которому ничто не маршрутизирует без фильтра Envoy, который этот каталог не отрисовывает, поэтому выбор не вступает в силу, и он не выбирает ни одной цели по стоимости. На core/gateway/traefik-hub каждое присоединение также останавливает сборку с указанием причины: Traefik выбирает по наименьшему времени ответа только среди серверов одного Service, которые охватывают одно имя модели и одни учётные данные, а между Service балансирует по весу или по хешу адреса клиента, никогда по задержке, и ни одна из его стратегий не выбирает цель по стоимости; кроме того, каждая подключённая к шлюзу модель обслуживается на собственном маршруте, несущем только эту модель, и выбирать не из чего. На любом другом шлюзе присоединение останавливает сборку.

  • Отказоустойчивость: core/fallback-chain передаёт запрос, модель которого даёт сбой, другим моделям: chains задаёт для каждого псевдонима модели, у которого есть резерв, псевдонимы, пробуемые по порядку, пока один не ответит, причём резервный вариант, давший сбой, в свою очередь следует собственной записи, а max_hops ограничивает, насколько далеко вдоль этой цепочки передаётся запрос. Стандартная библиотека реализует это на AI-шлюзе, записывая оба параметра в конфигурацию маршрутизации, которую рендерит сущность Recipe шлюза, и останавливает сборку на имени, которое карта моделей шлюза не публикует. Запрос переходит на резерв только после того, как шлюз отказался от запрошенного псевдонима: там, где псевдоним опубликован более одного раза, неудачный вызов сначала переходит к другой его записи как повторная попытка, ограниченная числом повторных попыток шлюза. core/retry-policy задаёт это число — сколько раз шлюз может отправить запрос, включая первую отправку (max_attempts), при сбое, который устраняется повторной отправкой, например отклонённом соединении, ограничении частоты или тайм-ауте, — и стандартная библиотека реализует это на AI-шлюзе, записывая его в конфигурацию маршрутизации, которую рендерит сущность Recipe шлюза. На core/gateway/envoy-gateway это реализуется как повторная попытка traffic policy на маршруте, обслуживающем подключённые модели, — той же policy, что несёт ограничение частоты бюджета на период, поскольку Envoy Gateway присоединяет к маршруту одну traffic policy: запрос отправляется повторно после отклонённого соединения или потока, сброса либо ответа 429, 503 или 504, до max_attempts отправок, а модели, которая ничего не отвечает в пределах тайм-аута запроса маршрута, запрос повторно не отправляется, поскольку этот тайм-аут охватывает все отправки. На core/gateway/azure-api-management это реализуется как повторная попытка Azure вокруг пересылки, в разделе backend policy API: запрос, на который ответили HTTP 429 или статусом 5xx, отправляется повторно, с телом, сохранённым для повторной отправки, через одну секунду после предыдущей отправки, до max_attempts отправок. После отклонённого или оборванного соединения, а также модели, которая ничего не отвечает в пределах тайм-аута пересылки, запрос повторно не отправляется, поскольку Azure прекращает повторные попытки при такой ошибке и передаёт её в раздел on-error policy. Azure повторяет от 1 до 50 раз после первой отправки, поэтому max_attempts, равный 1, не записывает никакой повторной попытки, а значение больше 51 отклоняется с явным указанием. Повторная попытка заменяет пересылку, которую API унаследовал бы, поэтому, пока она присоединена, настройка пересылки, заданная в более широкой области экземпляра, например тайм-аут, не применяется к API, который пересылает с параметрами Azure по умолчанию. На размещённом шлюзе core/retry-policy реализуется записью в ресурс шлюза его числа повторных попыток, которое задаёт отправки после первой, от 1 до 5, поэтому max_attempts от 2 до 6 учитывается, а любое другое значение отклоняется; core/fallback-chain там не реализуется, поскольку этот шлюз переходит между моделями только внутри маршрута, который запрос называет вместо модели, поэтому запрос к модели никогда не переходит на резерв. На core/gateway/kong-enterprise core/fallback-chain реализуется в его сущности Recipe для chart: маршруты chat и completion каждого псевдонима, которому chains даёт запись, несут AI Proxy Advanced от Kong вместо его AI proxy, с моделью псевдонима и моделями, на которые переходит его обход, в качестве целей в порядке приоритета — псевдоним, затем резервные варианты его записи по порядку, причём собственная запись резервного варианта, в свою очередь, учитывается лишь до тех пор, пока насчитано меньше max_hops. Балансировщик отправляет запрос каждой цели обхода по одному разу, по порядку, пока одна не ответит, переходя дальше после ошибки или тайм-аута соединения, недопустимого заголовка ответа либо ответа 429, 500, 502, 503 или 504, и возвращает любой другой ответ в том виде, в каком он пришёл. Сборка останавливается на имени, которого не несёт сокет models, на обходе, дважды достигающем одного псевдонима, рядом с core/retry-policy, поскольку Kong ведёт одно число повторных попыток на весь обход и не может повторно отправить запрос модели до перехода на резерв, а также на образе шлюза старше 3.12. core/retry-policy там не реализуется, и его реализация останавливает каждое присоединение с указанием причины: каждая подключённая модель обслуживается на собственных маршрутах, несущих только эту модель, поэтому повторная попытка должна снова отправить запрос той же цели, а справочник Kong допускает оба прочтения того, делает ли это его балансировщик. На core/gateway/agentgateway core/retry-policy реализуется в сущности Recipe для chart как policy повторных попыток собственной конфигурации шлюза, присоединённая к listener, на который поступают его запросы к моделям: запрос отправляется повторно, сразу и той же модели, после ответа 429, 500, 502, 503 или 504, отклонённого или сброшенного соединения, соединения, открытие которого занимает больше 11 секунд, или неудачного разрешения имени, до max_attempts отправок. agentgateway отправляет запрос на один раз больше, чем число попыток его policy, поэтому policy записывается как max_attempts минус один, max_attempts, равный 1, не записывает никакой, а значение больше 256 отклоняется с явным указанием. Запрос, тело которого больше 64 KiB, отправляется один раз, а конфигурация не задаёт тайм-аута, поэтому модель, которая принимает соединение и ничего не отвечает, ожидают, а не отправляют запрос повторно. core/fallback-chain там не реализуется, и его реализация останавливает каждое присоединение с указанием причины: agentgateway переключается между моделями, исключая сбойную модель для последующих запросов, тогда как на неудавшийся запрос отвечают его ошибкой, поэтому ни один запрос не проводится по цепочке. На core/gateway/higress core/retry-policy реализуется как собственная повторная попытка маршрута, записанная в виде аннотаций Ingress на каждом маршруте модели: запрос отправляется повторно после отклонённого или сброшенного соединения, ответа 5xx или 429, включая POST, до max_attempts отправок; max_attempts, равный 1, отключает повторные попытки, переопределяя повторную попытку, которую плоскость управления Higress даёт маршруту без аннотации, а значение больше 2147483648 отклоняется с явным указанием. Модели, которая принимает соединение, а затем ничего не отвечает или отвечает медленно, запрос повторно не отправляется, поскольку маршрут не задаёт крайнего срока на попытку, а потоковый запрос отправляется повторно только до начала его ответа. core/fallback-chain там тоже не реализуется, и его реализация останавливает каждое присоединение с указанием причины: Higress передаёт неудавшийся запрос дальше не более одного раза, в одно другое место назначения — backend маршрута по умолчанию или единственный резервный маршрут, который его консоль записывает для AI-маршрута, — поэтому ни один запрос не проводится по цепочке. На core/gateway/traefik-hub оба реализуются в сущности Recipe для chart, и каждый останавливает сборку на образе Traefik Hub старше v3.20, чей failover не принимает middleware на пробуемых сервисах, а чья повторная попытка не может повторно отправить POST по статусу ответа, — за исключением policy повторных попыток с одной отправкой. core/fallback-chain проводит маршрут каждого псевдонима, которому chains даёт запись, через вложенные failover самого Traefik, пробуя по порядку модели обхода псевдонима — псевдоним, затем резервные варианты его записи по порядку, причём собственная запись резервного варианта, в свою очередь, учитывается лишь до тех пор, пока насчитано меньше max_hops, — каждую с собственным именем модели, учётными данными, квотами и повторной попыткой. Ответ модели 429 или от 500 до 504, после возможной повторной попытки этой модели, передаёт запрос следующей; любой другой ответ возвращается в том виде, в каком пришёл, ответ последней модели — каким бы он ни был, а тело запроса больше 1 MiB отклоняется с HTTP 413 вместо отправки. Сборка останавливается на имени, которого не несёт сокет models, и на обходе, дважды достигающем одного псевдонима. core/retry-policy — это middleware повторных попыток Traefik, последний на каждом маршруте модели или на каждой модели, которую пробует обход: запрос отправляется повторно сразу после соединения, которое ничего не передало модели, и после ответа 429 или от 500 до 504, включая POST, до max_attempts отправок, включая первую, а max_attempts, равный 1, ничего не записывает. После ответа, который шлюз формирует сам, — отказа его проверки ключа, защиты, маскирования или квоты — запрос никогда не отправляется повторно, как и после потокового ответа, который уже начался.

  • Бюджет на период: core/period-budget ограничивает то, что трафик через шлюз может потребить за период: limit, period, который он охватывает, scope — всё, что обслуживает шлюз, каждая вызывающая сторона или каждая модель, — и unit — стоимость в долларах США или в токенах, — и как только то, что шлюз насчитал за период, превышает лимит, дальнейшие запросы к моделям отклоняются. Он присоединяется к любому компоненту, объявляющему dataplane.aggrega.ai/period-budget. Стандартная библиотека реализует его на AI-шлюзе, бюджет которого охватывает всё, что обслуживает шлюз, считается в долларах США и начинается заново в начале каждого периода — число дней от полуночи UTC или календарный месяц с его первого дня: реализация записывает лимит и период в конфигурацию, которую рендерит сущность Recipe шлюза, отклоняет по имени любую другую единицу, область или период — в том числе 30d, который шлюз считает календарным месяцем, — и останавливается, если не присоединены оба слота учётных данных шлюза database_url и api_key, потому что без своей учётной базы данных шлюз не ведёт никакого подсчёта, а без административного ключа не проверяет ни одну вызывающую сторону по бюджету. Как только счётчик превышает лимит, шлюз отклоняет запросы к моделям с административным ключом так же, как и запросы каждой вызывающей стороны; его список моделей и управление ключами по-прежнему отвечают этому ключу. На размещённом шлюзе он реализуется как правило лимита расходов на ресурсе шлюза, считаемое в долларах США за окно, которое движется вперёд со временем, — последний period, для моделей, цены которых шлюз знает, — для всего, что обслуживает шлюз: бюджет на вызывающую сторону или на модель, токены и календарный месяц отклоняются по имени. На core/gateway/apisix он реализуется в сущности Recipe типа chart и записывается на маршруты подключённых моделей как ограничение скорости по токенам APISIX: считается в токенах, которые сообщает ответ каждой модели, — total_tokens, prompt_tokens или completion_tokens — за фиксированное окно period, которое открывается первым запросом к модели после закрытия предыдущего окна, а не по часам, для всего, что обслуживает шлюз, для каждой подключённой модели отдельно или для каждой вызывающей стороны, которую сущность Release шлюза объявляет в infra.callers, отдельно, причём шлюз различает их по ключу, который предъявляет каждая. Как только счётчик достигает лимита, шлюз отвечает на запросы к моделям HTTP 503, пока окно не закроется; токены запроса добавляются, как только его ответ завершается, поэтому запрос, достигающий лимита, обслуживается, а ответ, выданный его семантическим кешем, ничего не добавляет к счётчику и выдаётся сверх лимита. APISIX не считает токены в запросе completion, поэтому, пока бюджет присоединён, каждая подключённая модель получает только свой маршрут чата, а счётчик он хранит в памяти процесса шлюза, поэтому chart запускает одну реплику, а перезапуск открывает новое окно. Бюджет в долларах США, бюджет на вызывающую сторону, пока infra.callers не объявляет ни одной, календарный месяц и второй бюджет на одном шлюзе отклоняются по имени, как и присоединение к его сущности Recipe типа workload, которая не рендерит ни одного маршрута. На core/gateway/envoy-gateway он реализуется как ограничение скорости Envoy Gateway на основе использования на AI-маршруте, обслуживающем модели, подключённые к шлюзу: маршрут объявляет счётчик токенов, который называет unit, — total_tokens, prompt_tokens или completion_tokens — как стоимость, которую Envoy AI Gateway считывает с каждого ответа, а traffic policy на этом маршруте списывает её, когда ответ завершается, из limit токенов на одну единицу ограничения скорости Envoy Gateway, для всего, что обслуживает шлюз, или для каждой подключённой модели отдельно. Каждое окно зафиксировано по часам UTC — секунда, минута, час, сутки от полуночи, неделя от четверга или 30 или 365 дней, отсчитанных от 1 января 1970 года, — а 1mo — это календарный месяц согласно настройке службы ограничения скорости Envoy Gateway, которая затем действует для каждого месячного ограничения скорости, которое ведёт эта установка. Счётчик ведёт служба ограничения скорости, которую плоскость управления Envoy Gateway создаёт и включает для каждого обслуживаемого ею шлюза, в хранилище с протоколом Redis, подключённом к сокету cache шлюза. Как только счётчик превышает лимит, шлюз отвечает на запросы к моделям HTTP 429, пока окно не закончится; токены запроса добавляются, как только его ответ завершается, поэтому запрос, пересекающий лимит, обслуживается. Пока хранилище или служба ограничения скорости недоступны либо проверка длится дольше тайм-аута ограничения скорости Envoy, запросы к моделям отклоняются с HTTP 500 согласно настройке плоскости управления Envoy Gateway, которая затем действует для каждого ограничения скорости, которое ведёт эта установка, поэтому ограничение скорости, применённое к ней вручную, тоже отказывает в закрытом режиме; запрос, допущенный непосредственно перед сбоем, всё равно обслуживается и не учитывается, потому что его токены списываются после ответа, а хранилище, держащее счётчик в памяти, при перезапуске начинает каждое окно заново. Бюджет в долларах США, бюджет на вызывающую сторону — шлюз различает вызывающие стороны только по заголовку, который вызывающая сторона пишет сама, и ничто на этом пути его не проверяет, — любой другой период и второй бюджет на одном шлюзе отклоняются по имени, как и присоединение, при котором к сокету models или cache ничего не подключено. На core/gateway/azure-api-management он реализуется как лимит токенов Azure, записанный в политику API: считается в токенах промпта и завершения, которые сообщает каждый ответ, вместе, для всего, что обслуживает API, или для каждой подписки API Management, ключ которой проверяет шлюз, — либо как квота за фиксированное окно по часам UTC, час, сутки, неделя, календарный месяц или календарный год (1h, 1d, 7d, 1mo или 12mo; Microsoft не сообщает, с какого дня начинается неделя), на превышение которой отвечают HTTP 403, либо как скорость за одну минуту (1m), на которую отвечают HTTP 429 и которая считается по скользящему окну на классических уровнях и как token bucket на уровнях v2. Счётчик — это использование, которое сообщает каждый ответ, поэтому параллельные запросы могут перейти лимит, а каждый шлюз экземпляра ведёт собственный счётчик. Бюджет в долларах США или только в токенах промпта или завершения, бюджет на модель — модель, которую называет запрос, пишет вызывающая сторона, и несколько имён могут вести к одной модели, — бюджет на подписку в API, не требующем ключа подписки, любой другой период и лимит, не являющийся целым числом, отклоняются по имени. Уровень Consumption не запускает никакого лимита токенов. На core/gateway/kong-enterprise он реализуется в сущности Recipe типа chart и записывается в маршруты, которые импортирует шлюз, как AI Rate Limiting Advanced от Kong: считается в токенах, которые сообщает ответ каждой модели, — total_tokens, prompt_tokens или completion_tokens — в фиксированных окнах period, равных числу секунд, минут, часов или дней, причём каждый запрос учитывается в том единственном окне, на которое приходится его время, для всего, что обслуживает шлюз, или для каждой подключённой модели отдельно, а запрос с областью model учитывается по псевдониму, который он назвал, независимо от того, какая модель ему ответила. Как только счётчик достигает лимита, на следующий запрос к модели отвечают HTTP 429, пока окно не закончится, поэтому запрос, пересекающий лимит, обслуживается; Kong также может отклонить запрос заранее, по собственной оценке токенов промпта, которые тот несёт. Счётчик хранится в бэкенде PostgreSQL шлюза, является общим для всех реплик и сохраняется после перезапуска. Бюджет в долларах США — Kong считает стоимость только по цене, которую его конфигурация назначает каждой модели, а каталог ни одной не предоставляет, — бюджет на вызывающую сторону — Kong различает вызывающие стороны только как потребителей, которых называет плагин аутентификации, а шлюз не объявляет вызывающих сторон по причинам, приведённым выше в «Kong перед моделями», — календарный месяц, второй бюджет на одном шлюзе и образ шлюза старше 3.15 отклоняются по имени, как и присоединение, при котором к сокету models ничего не подключено. На core/gateway/agentgateway он реализуется в сущности Recipe типа chart, записывается в конфигурацию шлюза и считается в общем числе токенов, которое сообщает каждый ответ: в области caller — как бюджет на API-ключе каждой вызывающей стороны, которую сущность Release шлюза объявляет в infra.callers, за фиксированные окна period, выровненные по эпохе Unix, где сутки начинаются в полночь UTC, хранимый в хранилище SQLite на томе, который рендерит сущность Recipe, с одной репликой; в области gateway или model — как token bucket для всего, что обслуживает шлюз, или для каждого имени модели, которое запрашивает запрос, пополняемый до лимита каждый period с момента, когда шлюз прочитал свою конфигурацию, и хранимый в его памяти, поэтому перезапуск или изменённая конфигурация пополняет его снова. Как только насчитанное достигает лимита, на запросы к моделям отвечают HTTP 429, пока окно не закончится или bucket не пополнится; запрос, который его достигает, обслуживается. Бюджет в долларах США — каталог стоимости моделей шлюза не содержит цен ни для одной из подключённых к нему моделей, поэтому бюджет ничего бы не считал, — только в токенах промпта или завершения, бюджет на вызывающую сторону, пока infra.callers не объявляет ни одной, календарный месяц, лимит, не являющийся целым числом, и второй бюджет на одном шлюзе отклоняются по имени, как и присоединение, при котором к сокету models ничего не подключено; его сущность Recipe типа compose не имеет реализации этого. На core/gateway/traefik-hub он реализуется в сущности Recipe типа chart как middleware квот Traefik Hub на маршруте каждой подключённой модели, которое ведёт счётчик в хранилище с протоколом Redis, подключённом к сокету cache шлюза: оно считает токены, которые сообщает каждый ответ, — total_tokens, prompt_tokens или completion_tokens — или, при usd, их стоимость в долларах США по ценам из списка моделей, поставляемого с middleware, причём модель, для которой у него нет цены, отклоняется с HTTP 422, за окно, скользящее со временем, где насчитанное в какой-то момент снова освобождается через один период, для каждой подключённой модели отдельно или для всего, что обслуживает шлюз, пока подключена одна модель. Как только счётчик достигает лимита, запросы к моделям отклоняются с HTTP 429; счёт запроса добавляется, как только его ответ завершается, поэтому запрос, пересекающий лимит, и любой, обслуживаемый рядом с ним, обслуживается, а ответ, выданный семантическим кешем, ничего не добавляет. Справочник Traefik сообщает, что квота обслуживает запросы без учёта, пока хранилище недоступно. Бюджет на вызывающую сторону — квота различает запросы по адресу клиента, заголовку запроса или хосту запроса, и ни один из них не является вызывающей стороной, которую проверила проверка ключей шлюза, — бюджет на весь шлюз, пока подключено несколько моделей, поскольку справочник Traefik не сообщает, разделяют ли маршруты, называющие одну квоту, её счётчик, календарный месяц и любой период, кроме часов или дней либо минут или секунд, составляющих целые часы, отклоняются по имени, как и лимит, не являющийся целым числом токенов, и присоединение, при котором к сокету models или cache ничего не подключено. На core/gateway/higress он реализуется в сущности Recipe типа chart как плагин лимита токенов Higress на маршруте каждой подключённой модели, который ведёт счётчик в хранилище с протоколом Redis, подключённом к сокету cache шлюза: он складывает токены промпта и завершения, которые сообщает каждый ответ, вместе, как только ответ завершается, за фиксированное окно period — секунда, минута, час или сутки, — которое открывается, когда в нём учтён первый ответ, для всего, что обслуживает шлюз, или для каждого псевдонима отдельно. Пока счётчик превышает лимит, на запросы к моделям отвечают HTTP 429, пока окно не закончится, поэтому запрос, пересекающий лимит, обслуживается. Ответ, не сообщающий об использовании, ничего не добавляет, поэтому сущность Recipe просит модель потокового запроса сообщать своё использование и отклоняет с HTTP 403 потоковый запрос, отключающий это сообщение, запрос, тип содержимого которого не содержит application/json и не начинается с multipart/form-data, который AI-прокси пересылает, не запрашивая сообщения, и запрос, тело которого плагины шлюза не читают, — сжатое тело, тип содержимого, содержащий octet-stream или grpc, upgrade; клиент, намеренно отправляющий тело, которое валидация шлюза не может декодировать, обходит эти отказы, и такой потоковый запрос остаётся неучтённым. Когда маскирование не присоединено, запрос, тело которого превышает буфер шлюза в 32 KiB, может быть отклонён с HTTP 413 в зависимости от того, когда ответит хранилище. Пока хранилище недоступно, запросы к моделям обслуживаются и не учитываются: у плагина нет настройки, которая бы тогда их отклоняла. Бюджет в долларах США или только в токенах промпта или завершения, бюджет на вызывающую сторону — шлюз не объявляет вызывающих сторон, поэтому не проверяет ни одной, — любой другой период, лимит, не являющийся целым числом, и второй бюджет на одном шлюзе отклоняются по имени, как и присоединение, при котором к сокету models или cache ничего не подключено.

  • Параллелизм: core/concurrency-limit ограничивает, сколько запросов шлюз несёт одновременно (max_in_flight), что не даёт всплеску вызывающих сторон превратиться в очередь к модели за ним. scope определяет, что считает одно ограничение: gateway, значение по умолчанию, считает вместе каждый запрос, который пересылает шлюз; model даёт каждой цели, которой шлюз отправляет запросы, собственный счётчик, где целью является каждая upstream-запись, на которую шлюз маршрутизирует, поэтому там, где у одного имени модели несколько записей, каждая считается отдельно. Ограничение и его область — это определение ёмкости, которое решает оператор и задаёт в infra присоединения, поэтому оператор присоединяет его в сущности Release. Ограничение считается для каждого запущенного прокси, поэтому там, где работает несколько реплик, каждая из них допускает столько же. Оно присоединяется к любому компоненту, объявляющему dataplane.aggrega.ai/concurrency-cap, а реализация отклоняет по имени область, которую её шлюз не считает. На core/gateway/nginx область gateway реализуется как limit_conn NGINX с ключом из одного слова, одинакового для каждого запроса, поэтому NGINX считает каждый обрабатываемый им запрос как одну общую сумму, хранящуюся в памяти, разделяемой его рабочими процессами, и отвечает на запрос сверх ограничения HTTP 503; область model отклоняется, поскольку NGINX не ведёт счётчика для каждой upstream-цели, как и max_in_flight больше 65535 — максимума, который принимает limit_conn. На core/gateway/envoy-gateway область model реализуется как circuit breaker traffic policy на маршруте, обслуживающем подключённые модели, — той самой policy, которая также несёт ограничение скорости бюджета на период и повтор политики повторов: Envoy Gateway применяет его к бэкенду каждого правила этого маршрута, а у каждой подключённой модели есть собственное правило, поэтому каждой подключённой модели одновременно отправляется не более max_in_flight запросов, а на запрос сверх ограничения отвечают HTTP 503 и повторно его не отправляют; отправка, которую повторяет политика повторов, учитывается в ограничении так же, как первая. Рабочие потоки Envoy проверяют счётчик, а затем увеличивают его, поэтому запросы, поступающие одновременно, могут ненадолго поднять его выше ограничения. Область gateway отклоняется, поскольку Envoy Gateway ведёт ограничение для каждого бэкенда и ни одного для их суммы, как и присоединение, при котором к сокету models ничего не подключено. На AI-шлюзе область model реализуется как max_parallel_requests каждой записи его карты моделей, как введённой вручную, так и подключённой: к каждой записи одновременно выполняется не более max_in_flight запросов, а на запрос, застающий свою запись заполненной, отвечают HTTP 429 — после повторов шлюза, если у его псевдонима одна запись, и сразу, если их несколько, даже когда в другой из них есть место, поскольку прокси выбирает запись до того, как считать, — если только core/fallback-chain не перечисляет резервные модели для его псевдонима, которым его тогда и отправляют. Прокси хранит каждый счётчик в памяти, где по умолчанию запись истекает через десять минут после создания и новый счётчик тогда начинается с нуля, поэтому присоединение также устанавливает это время жизни в сто лет, сохраняя каждый счётчик, пока работает прокси. Из-за этого времени жизни шлюз отклоняет запрос, содержащий priority, пока ограничение присоединено, даже там, где сущность Release допускает это поле, поскольку прокси хранит запись очереди для каждого такого запроса, пока его запись не истечёт; а сборка останавливается на карте моделей более чем из 100 записей, сверх которых хранилище, где держатся счётчики, вмещающее 200 записей и отбрасывающее одну всякий раз, когда оно заполнено, могло бы отбросить счётчик. Область gateway там отклоняется, поскольку единственную общую сумму прокси читает только ограничитель запросов, который включает переменная окружения и который учитывает запрос в течение его первой секунды. Не реализует его и размещённый шлюз: лимит запросов, который его сущность Recipe типа terraform записывает в ресурс шлюза, — это скорость, число запросов за интервал, а не ограничение на выполняющиеся запросы.

  • Журналирование аудита: core/audit-logging заставляет шлюз хранить запись о каждом обслуживаемом им запросе к модели с указанием ответившей модели и токенов, о которых сообщает ответ, а каждая реализация указывает, куда попадает запись. Его присоединяют к любому компоненту, имеющему gateway.aggrega.ai/intelligence: semantic, а три его значения принадлежат оператору и задаются в его infra, поэтому присоединяет его оператор в сущности Release. require_cost, включённое по умолчанию, заставляет запись также указывать, сколько стоил каждый запрос, в валюте, которую называет реализация. require_verified_caller, включённое по умолчанию, заставляет запись называть клиента, которого проверил шлюз, по ключу, который шлюз выдал или проверил. retention_days, не заданное по умолчанию, заставляет шлюз удалять запись, как только ей исполнится столько дней; без него сам шлюз не удаляет ни одной записи, и запись существует, пока её хранит место, куда она попала. Шлюз, который не может соблюсти значение, отклоняет присоединение при сборке, называя это значение, поэтому присоединение, оставляющее require_cost и require_verified_caller со значениями по умолчанию, получает стоимость и проверенного клиента либо остановку. Отключение require_verified_caller означает принятие записи, клиентом в которой является тот, кем назвался сам запрос, или вовсе никакой клиент: любой, кто отправляет запрос, может тогда сделать так, чтобы он был записан на другого клиента, поэтому такая запись не показывает, кто отправил запрос. На AI-шлюзе запись — это строка в учётной базе данных шлюза, и каждое значение соблюдается: строка указывает, сколько стоил запрос в долларах США, по цене из таблицы, которую шлюз ведёт для каждой модели, — модель, для которой в таблице нет цены, записывается как бесплатная, — и называет ключ, который проверил шлюз, вместе с пользователем и командой, которым принадлежит ключ, тогда как конечный пользователь, которого называет строка, — это тот, кого вписывает запрос, без проверки. Без своей учётной базы данных шлюз не записывает ни одной строки, а без административного ключа не проверяет ни одного клиента и не записывает строку для запроса, который не предъявляет ключа и не называет конечного пользователя, поэтому сборка останавливается, если оба слота учётных данных шлюза, database_url и api_key, не присоединены; пока values.log_masking шлюза перечисляет, что маскировать, он записывает только запросы, на которые был дан ответ. На core/gateway/envoy-gateway запись — это строка журнала доступа шлюза, которую пишет его Recipe, пока присоединение присутствует: одна строка JSON на запрос в стандартном выводе плоскости данных, содержащая поля, которые Envoy Gateway пишет по умолчанию, модель, названную запросом, ответившую модель и токены промпта, дополнения и общие, о которых сообщает ответ, причём маршрут, обслуживающий модели, объявляет эти счётчики, чтобы Envoy AI Gateway их записывал. Запрос, на который модель не ответила, не содержит ответившей модели и токенов, а журнал доступа сам ничего не хранит, поэтому то, как долго существует строка, зависит от того, что собирает этот вывод. Ни одно поле не называет клиента, проверенного шлюзом: адрес клиента и отправляемые им заголовки записываются в том виде, в каком они приходят. Шлюз не ведёт цен, ничто на маршруте, который генерирует его Recipe, не проверяет клиента, а журнал доступа не хранит записи, которую мог бы удалить, поэтому его реализация собирает присоединение, которое отключает require_cost и require_verified_caller и не задаёт retention_days, а иначе останавливается, называя каждое значение, которое не может соблюсти, все в одной ошибке; она также останавливается, когда к сокету models ничего не подключено. На core/gateway/agentgateway запись — это строка, которую шлюз пишет в хранилище SQLite на томе, генерируемом его Recipe типа chart, пока присоединение присутствует, с одной репликой, для каждого запроса к модели, проходящего его проверки ключа, бюджета и авторизации, включая отказ guard: модель, которую шлюз запросил у сервера моделей, — имя, публикуемое подключённой моделью, а не псевдоним, отправленный клиентом, — и ответившая модель, входные, выходные и общие токены, о которых сообщает ответ, его статус и время, а также для каждого клиента, которого его сущность Release объявляет в infra.callers, имя этого клиента, полученное из API-ключа, проверенного шлюзом. Запрос, отклонённый из-за его ключа, правилом авторизации или бюджетом клиента, не оставляет строки. Никакой текст промпта или ответа не хранится, а строки читаются через административный интерфейс шлюза, который слушает внутри его пода. require_verified_caller соблюдается, пока объявлены клиенты; require_cost отклоняется с указанием имени, поскольку каталог стоимости моделей шлюза не задаёт цену ни одной из подключённых к нему моделей, как и require_verified_caller без объявленного клиента и retention_days, поскольку шлюз не удаляет ни одной записи; его Recipe типа compose не имеет реализации этого. На core/gateway/higress запись — это поле ai_log строки журнала доступа шлюза, которое заполняет плагин статистики Higress, пока присоединение присутствует: ответившая модель и входные, выходные и общие токены, о которых сообщает ответ, в стандартном выводе шлюза, без текста промпта или ответа. Шлюз не объявляет клиентов, ничего не оценивает и не хранит записи, которую мог бы удалить, поэтому его реализация собирает присоединение, которое отключает require_cost и require_verified_caller и не задаёт retention_days, а иначе останавливается, называя каждое значение, которое не может соблюсти, все в одной ошибке; она также останавливается, когда к сокету models ничего не подключено. На core/gateway/traefik-hub каждое присоединение останавливается с указанием причины: Traefik Hub хранит запись о запросе к модели только как span OpenTelemetry, который его AI-middleware экспортируют в бэкенд трассировки, — с указанием модели, а на подробном уровне также токенов и их стоимости в долларах США, — а его реализация не подключает никакого бэкенда трассировки, поэтому запись никуда бы не попала; span также не называет клиента, поэтому не может назвать того, кого проверила проверка ключа шлюза. На core/gateway/azure-api-management каждое присоединение останавливается, как сказано в пункте об этом шлюзе выше, и ни один другой шлюз стандартной библиотеки этого не реализует, поэтому присоединение к любому другому шлюзу останавливается с указанием типа.

  • Семантическое кеширование: core/semantic-caching объявляет кеш, который отвечает на промпт ответом, сохранённым для более раннего промпта, достаточно близкого по смыслу, вместо того чтобы снова вызывать модель. embedding_model называет модель, которая превращает каждый промпт в вектор, в том виде, в каком её публикует шлюз; сохранённый ответ выдаётся, когда два промпта похожи как минимум на similarity_threshold, и он остаётся пригодным в течение ttl_seconds. scope определяет, кто совместно использует кеш: end_user, значение по умолчанию, держит отдельно каждого конечного пользователя, которого идентифицирует шлюз, тогда как key обслуживает из одного кеша каждого клиента, предъявляющего один и тот же ключ, поэтому конечному пользователю за этим ключом может быть выдан ответ, сгенерированный для другого. core/data-masking объявляет конфликт с ним, поэтому сборка останавливается на компоненте, несущем оба. Стандартная библиотека реализует его на AI-шлюзе, который хранит ответы в core/datastore/redis, подключённом к его сокету cache_store, предъявляя хранилищу пароль, содержащийся в учётных данных этого подключения, когда хранилище его требует, причём хранилище удаляет каждый ответ по истечении ttl_seconds; шлюз кеширует запросы chat, responses и messages, но не completions и не embeddings. Реализация останавливает сборку, если слот api_key шлюза не присоединён, поскольку без административного ключа шлюз не проверяет ни одного клиента, а также на embedding_model, которую не публикует карта моделей шлюза, и когда к cache_store ничего не подключено. Сохранённый ответ выдаётся только запросу, соответствующему тому, под чем он сохранён: ключу, который предъявляет запрос и который проверяет шлюз, вместе с командой и организацией этого ключа; при end_user — конечному пользователю, которого называет запрос; и модели, которую запрашивает запрос, с прочими его параметрами. Шлюз записывает ключ, команду, организацию и конечного пользователя в сам запрос поверх любого значения, которое клиент отправил для них в запросе chat; в запросе responses или messages он удаляет поле команды, организации или конечного пользователя из собственных метаданных запроса и отклоняет поле, называющее там ключ, поэтому ни один запрос не может добраться до ответов другого ключа, просто назвав его. Собственные метаданные запроса всё же могут перемещать его между ответами ключа, который он предъявляет: в запросе responses model_group заменяет запрашиваемую модель в том, под чем сохраняется его ответ; в запросе responses или messages caching_groups позволяет запросам, называющим одну и ту же группу псевдонимов моделей, совместно использовать ответы между ними; а в запросе responses или chat redis_namespace держит запросы, называющие пространство имён, отдельно от тех, что не называют никакого. Шлюз читает конечного пользователя из заголовка или поля тела, которое называет сам запрос, и не проверяет ни одного из них: при end_user клиенту, называющему другого конечного пользователя, выдаются ответы этого конечного пользователя, а запросы, не называющие конечного пользователя, совместно используют один кеш со всеми другими такими запросами под предъявляемым ими ключом. Размещённый шлюз этого не реализует: его кеш отвечает только на запрос, идентичный более раннему. На core/gateway/azure-api-management он реализован как поиск и сохранение семантического кеша Azure, записанные в политику API: embedding_model называет бэкенд, который экземпляр API Management уже имеет для модели embeddings и к которому экземпляр обращается с помощью своего управляемого удостоверения, а экземпляру нужен кеш Redis с RediSearch, настроенный как его внешний кеш, и ничего из этого сборка не видит, поэтому сборка останавливается, пока оператор не подтвердит, что кеш поддерживает RediSearch, задав infra.cache_serves_vector_search шлюза; хранилище держит ответ в течение ttl_seconds; а similarity_threshold записывается как порог оценки Azure, единица минус порог, при этом оценка читается как косинусное расстояние, поскольку Microsoft приводит её диапазон и направление — меньшее значение требует более близких промптов, — но не её меру. Ответ сохраняется и выдаётся отдельно для каждого API и каждой подписки API Management, ключ которой проверяет шлюз, поэтому реализация сохраняет key, отклоняет его на API, не требующем ключа подписки, и отклоняет end_user: API, которое генерирует его Recipe, не проверяет токен ни одного конечного пользователя, поэтому у шлюза нет проверенного конечного пользователя, которого нужно держать отдельно. core/gateway/contour и core/gateway/nginx тоже его не реализуют, поскольку не предлагают семантического кеша. На core/gateway/agentgateway его реализация останавливает каждое присоединение с указанием причины: agentgateway не держит кеша ответов, а его кеширование промптов лишь отмечает, где это может сделать поставщик, который сам кеширует промпты. На core/gateway/kong-enterprise его реализация останавливает каждое присоединение, называя запрошенную область: AI Semantic Cache в Kong не имеет настройки, которая держала бы сохранённые ответы одного клиента отдельно от ответов другого, а шлюз различает клиентов только как consumers, которых называет плагин аутентификации, и не объявляет клиентов по причинам, приведённым выше в разделе «Kong перед моделями», поэтому и при end_user, и при key каждый запрос совместно использовал бы один кеш. На core/gateway/higress его реализация останавливает каждое присоединение, называя запрошенную область: семантический кеш Higress сохраняет каждый ответ под одним префиксом ключа, за которым следует текст промпта, и ничто в этом ключе не называет клиента или конечного пользователя, тогда как шлюз не объявляет клиентов, поэтому каждый запрос совместно использовал бы один кеш. На core/gateway/apisix он реализован в Recipe типа chart, записан на маршрут chat каждой подключённой модели как семантический кеш APISIX 3.18.0, для клиентов, которых его сущность Release объявляет в infra.callers: ответ сохраняется для каждого маршрута и каждого клиента под ключом, который предъявил клиент и который проверяет шлюз, поэтому ни одному клиенту не выдаётся ответ, сохранённый для другого; реализация сохраняет key и отклоняет end_user с указанием имени, поскольку шлюз не может различить конечных пользователей за одним ключом. embedding_model называет подключение на сокете models шлюза, с конечной точкой, моделью и учётными данными которого кеш вычисляет embeddings. Кеш вычисляет embedding последнего сообщения пользователя в запросе и выдаёт сохранённый ответ, сообщение которого похоже как минимум на similarity_threshold, а предыдущие сообщения — системный промпт, предыдущие реплики — те же самые. Ответы хранятся в течение ttl_seconds в core/datastore/redis, подключённом к сокету cache_store шлюза, которому кеш предъявляет пароль, содержащийся в учётных данных этого подключения, а ответ, выданный по смыслу, снова сохраняется под этим запросом ещё на ttl_seconds. Запросы completion не кешируются, а сбой хранилища или вычисления embedding считается промахом: на запрос всё равно даётся ответ. Реализация останавливается, когда не объявлено ни одного клиента, когда к cache_store или к сокету models ничего не подключено, и на embedding_model, которую не несёт ни одно подключение там. APISIX привязывает сохранённый ответ к маршруту и клиенту, а не к шлюзу, поэтому два шлюза APISIX, подключённые к одному хранилищу, или две сущности Releases одной сущности Aggregate, направляющие свой шлюз на одно внешнее хранилище, могут выдать кешированный ответ клиенту с тем же именем на том же псевдониме и модели. Его Recipe типа workload, на APISIX 3.17.0, вообще не содержит семантического кеша. На core/gateway/traefik-hub он реализован в Recipe типа chart как семантический кеш Traefik Hub на маршруте каждой подключённой модели, для клиентов, которых его сущность Release объявляет в infra.callers: ответ сохраняется для каждой подключённой модели и каждого клиента под клиентом, которого проверила проверка ключа шлюза, каждого по его собственному ключу, поэтому ни одному клиенту не выдаётся ответ, сохранённый для другого; реализация сохраняет key и отклоняет end_user с указанием имени, поскольку шлюз не может различить конечных пользователей за одним ключом. embedding_model называет подключение на сокете models шлюза, с конечной точкой, моделью и учётными данными которого кеш вычисляет embedding текста запроса. similarity_threshold записывается как граница расстояния кеша, единица минус порог, читаемая как косинусное расстояние, поскольку справочник Traefik приводит направление границы, но не её меру. Ответ хранится в течение ttl_seconds в core/datastore/redis, подключённом к сокету cache_store шлюза, а на запрос, слишком большой для вычисления embedding, отвечают без кеша. Реализация останавливается, когда не объявлено ни одного клиента, когда к cache_store или к сокету models ничего не подключено, на embedding_model, которую не несёт ни одно подключение там, и на образе Traefik Hub, тег которого не называет версию начиная с v3.19.11 в пределах 3.19 или начиная с v3.20.6, поскольку более ранняя версия использует один кеш для всех клиентов маршрута.

  • Проверка на prompt injection: core/prompt-injection-shield объявляет, что запросы к моделям, которые пересылает gateway, перед вызовом модели проверяются на попытку переопределить инструкции, данные модели, с sensitivity уровня standard или strict — strict отклоняет больше таких попыток, а вместе с ними и больше легитимных запросов. Проверка — это вердикт вероятностного классификатора: она пропускает некоторые атаки — в том числе переформулированные, закодированные или записанные иначе, — отклоняет некоторые легитимные запросы и, как известно, поддаётся обходу, поэтому это одна мера контроля наряду с другими, и она не оценивает ответ модели, аргументы вызовов инструментов и изображения. Её можно присоединить к любому gateway, и реализация либо пропускает запросы gateway через охранника, подключённого к его сокету guard, что не требует от gateway ничего, кроме пересылки на настроенный адрес, либо включает проверку, которую gateway выполняет сам. С охранником именно охранник проверяет каждый запрос и пересылает модели то, что допускает, а присоединение Feature без чего-либо на этом сокете останавливает сборку с указанием на это. Стандартная библиотека реализует её на AI-gateway и на NGINX-gateway, в обоих случаях с core/security/nemo-guardrails в роли охранника: это сервис, работающий через API chat-completions от OpenAI, rail которого отправляет последнее сообщение пользователя из запроса классификатору подключённого к нему core/security/trustyai-huggingface-detector и отклоняет запрос, когда оценка этого классификатора достигает порога охранника. На отклонённый запрос отвечает сам охранник обычным completion, и ничто из него не доходит до модели; если охранник или его детектор недоступны, запрос тоже отклоняется. Каждый из двух останавливает сборку, если охранник не является именно этим сервисом с порогом, который задаёт чувствительность, — 0.5 для standard и 0.001 для strict, два значения, измеренные для классификатора детектора по умолчанию, модель которого gateway, видящий охранника, а не детектор за ним, проверить не может. На AI-gateway каждый псевдоним карты моделей отправляется охраннику, а каждая цель записывается как openai/<model>, поэтому карта — это та, что записана вручную: модель, подключённая к сокету models gateway, была бы отправлена на собственный endpoint с учётными данными собственного соединения в обход охранника, поэтому реализация останавливает сборку, пока этот сокет содержит соединение, и называет его. AI-gateway отклоняет любой запрос, кроме chat completion — единственного типа, который проверяет охранник; на NGINX-gateway его единственная location пересылает охраннику вместо upstream, и охранник не отвечает ни на какой другой маршрут модели. На core/gateway/azure-api-management она реализуется как собственный prompt shield от Azure, включаемый в policy API через бэкенд Azure AI Content Safety экземпляра, который задаёт infra.content_safety_backend_id, и сборка останавливается, пока этот ключ не задан: Azure AI Content Safety проверяет каждый запрос на атаку пользователя перед вызовом модели, ещё до поиска в семантическом кэше, и gateway отвечает HTTP 403 на запрос, в котором обнаружил атаку, так же как отвечает на запрос длиннее, чем принимает сервис. Shield либо включён, либо выключен, поэтому standard сохраняется, а strict отклоняется по имени, и он работает с собственной чувствительностью Microsoft, не измеренной относительно порога, который standard задаёт для охранников. Экземпляр обращается к этому бэкенду через свою управляемую идентичность, которой нужна роль Cognitive Services User для сервиса; сборка не видит ни того, ни другого. Ни один gateway стандартной библиотеки, кроме этих трёх, её не реализует, и присоединение её к другому останавливает сборку с указанием типа: большинство не генерирует ни одного маршрута, который реализация могла бы пропустить через охранника, — они хранят маршруты в собственном хранилище, берут их у сервисов за ними или являются размещённым сервисом, на котором стандартная библиотека не включает никакой проверки такого рода, — а у core/gateway/apisix, Recipe чарта которого генерирует маршруты подключённых к нему моделей, и у core/gateway/envoy-gateway, Recipe которого генерирует AI-маршрут подключённых к нему моделей, её реализации нет. На core/gateway/agentgateway, Recipes которого генерируют запись для каждой подключённой к нему модели, реализация останавливает каждое присоединение с указанием причины: agentgateway оценивает запрос на такую попытку только через вызываемый им сервис — webhook, который запускает оператор, или Azure AI Content Safety, Google Model Armor либо AWS Bedrock Guardrails, — и реализация не подключает ни один из них. На core/gateway/higress реализация тоже останавливает каждое присоединение с указанием причины: Higress оценивает такую попытку только через вызываемый им сервис — сервис безопасности контента Alibaba Cloud или, через плагин, который есть в его исходном коде, но не опубликован в его выпуске плагинов 2.2.5, сервис модели Qwen3Guard, который запускает оператор, — и каждый из них пропускает запрос, если этот вызов завершается неудачей, а реализация не подключает ни один из них. На core/gateway/traefik-hub реализация так же останавливает каждое присоединение с указанием причины: Traefik Hub оценивает такую попытку только через вызываемый им сервис — свои middleware LLM Guard и Parallel LLM Guard, которые вызывают сервис охранника или модель с запросом и условиями, которые реализации пришлось бы записать, и работа которых с детектором атак на промпты не измерена, так что никакая чувствительность там не соответствует проверке; или свои middleware Azure Prompt Shield, Amazon Bedrock Guardrails и GCP Model Armor, которые вызывают размещённые сервисы, не подключаемые реализацией. Охранник читает только последнее сообщение пользователя, поэтому системное сообщение, предыдущий ход или результат инструмента доходит до модели непрочитанным, и проверяется только трафик, проходящий через gateway: рабочая нагрузка, вызывающая адрес модели напрямую, обходит его.

  • Валидация ответов и оценки: core/response-validation объявляет проверку ответа модели на соответствие JSON Schema до того, как он дойдёт до вызывающей стороны: schema содержит саму схему, и ответ, который ей не соответствует, отклоняется вместо передачи дальше — или, при включённом invert, ответ, который ей соответствует. Схема принадлежит присоединению и одинакова для каждого запроса, а не отправляется вызывающей стороной в её собственном запросе, поэтому разработчик присоединяет её в сущности Aggregate, записывая схему в её values. Ни одна реализация стандартной библиотеки её не обеспечивает: на core/gateway/agentgateway её реализация останавливает каждое присоединение с указанием причины — охранники ответов agentgateway сопоставляют шаблоны или вызывают сервис content safety либо webhook, и ни один из них не принимает схему, — так же как и её реализация на core/gateway/higress, проверка ответов которой на прошедший её ответ отвечает голым JSON, найденным в сообщении ответа, вместо chat completion, который возвращает её маршрут OpenAI, пропускается любым клиентом, отправляющим заголовок запроса X-HIGRESS-AI-JSON-RESP: true, и оставляет непроверенной схему с вложенностью более шести уровней; и так же её реализация на core/gateway/traefik-hub, поскольку ни один middleware в справочнике Traefik Hub не проверяет ответ на соответствие схеме — его middleware Chat Completion проверяет запросы на соответствие схеме chat completion, его управление API проверяет тела запросов на соответствие документу OpenAPI, а его LLM Guard отправляет ответ внешнему сервису, который реализация не подключает; на любом другом gateway присоединение останавливает сборку с указанием типа. core/traffic-shadowing копирует живые запросы во второй сервис и отбрасывает ответы этого сервиса, так что модель-кандидат или сервис-кандидат можно оценить под реальным трафиком, не показывая его вывод ни одной вызывающей стороне. Её можно присоединить к любому компоненту, объявляющему dataplane.aggrega.ai/request-mirroring, чего AI-gateway не делает; стандартная библиотека реализует её на NGINX-gateway, который копирует весь поток, а не его долю, и останавливается на меньшей доле, называя её.

5. Асинхронное выполнение и инфраструктура HITL

Aggrega рассматривает фреймворки с участием человека (например, AutoGen и LangGraph) как узлы-воркеры. Чтобы поддерживать «спящих» агентов, ожидающих ввода от человека без потери состояния, архитекторы платформы могут объявлять сокеты usesSchema на сущностях Components этих агентов, которые строго требуют явной привязки к ним компонентов категории datastore, выбираемых по метке движка datastore — datastore.aggrega.ai/engine in (vector, semantic-memory, search) для хранилища, из которого агент извлекает данные по сходству, или datastore.aggrega.ai/engine=kv для хранилища, в которое он записывает контрольные точки состояния своего выполнения. Сокет привязывается к метке движка, а не к названию продукта, поэтому автор выбирает, какое хранилище будет подключено, а объявление по-прежнему выполняется. Кроме того, для циклов обратной связи от человека к агенту (например, интеграций со Slack) можно настроить роль вердикта governance, которая будет отклонять архитектуру, если не присоединён явно объявленный компонент gateway, чтобы callback-вебхуки входили через объявленную границу входящего трафика.

Агенты, построенные на фреймворке или SDK, вокруг которого написано приложение, а не поставляемые как отдельный продукт, имеют в стандартной библиотеке одну форму. Сущность Release задаёт образ приложения, который каталог не фиксирует. Сокет model передаёт то, что фреймворк читает из подключённой модели, — её адрес и имя модели, там, где фреймворк их читает, и учётные данные соединения, по ссылке, — в переменные, которые читает этот фреймворк. Там, где фреймворк не определяет собственного сервера, компонент является worker и не открывает ни одного порта: такую форму имеют core/ai-agent/crewai и core/ai-agent/langgraph, а также core/ai-agent/openai-agents-sdk, сокет model которого принимает только модель или gateway с model.aggrega.ai/api: openai, core/ai-agent/claude-agent-sdk, сокет которого принимает только элемент с model.aggrega.ai/api: anthropic, и core/ai-agent/agent-framework — для приложения, построенного на Microsoft Agent Framework, которое само ничего не обслуживает, — сокет которого принимает только элемент с model.aggrega.ai/api: openai и передаёт переменные, которые читают Python-клиенты OpenAI из Agent Framework; эти три останавливают сборку, называя infra.image, пока сущность Release его не задаст. OpenAI Agents SDK по умолчанию выгружает трассу каждого запуска в OpenAI, поэтому core/ai-agent/openai-agents-sdk отключает эту выгрузку, если сущность Aggregate не задаст своё значение upload_traces_to_openai равным true. Там, где фреймворк сам обслуживает HTTP, компонент является server на собственном порту фреймворка и публикует адрес, по которому обращается вызывающая сторона, как host, port, endpoint и protocol, и он тоже останавливает сборку, называя infra.image, пока сущность Release его не задаст: core/ai-agent/google-adk обслуживает REST API ADK на порту 8000 и передаёт ключ, который клиент Gemini из ADK отправляет в Gemini API, причём его сокет model принимает только модель с model.aggrega.ai/api: gemini, например core/ai-model/gemini, и никогда не gateway, адрес которого клиент ADK не прочитал бы; core/ai-agent/mastra обслуживает сервер, который собирает Mastra, на порту 4111, готовый в Kubernetes, как только отвечает его маршрут /health, принимает модель или gateway с model.aggrega.ai/api: openai и там, где сущность Aggregate называет одного из агентов приложения в своём значении agent_id, публикует адрес карточки Agent2Agent этого агента, чтобы core/ai-tool/agent-invocation мог делегировать ему. Маршруты обоих серверов отвечают любой вызывающей стороне, если приложение их не аутентифицирует, поэтому присоединение core/public-ingress или core/http-route к любому из них останавливает сборку, пока сущность Release не задаст свой infra.routes_authenticated равным true, подтверждая, что приложение аутентифицирует каждый запрос, который принимают его маршруты. Среды выполнения SDK и серверов, а также core/ai-agent/agent-framework также объявляют необязательный сокет tools, который передаёт адрес каждого подключённого инструмента и учётные данные соединения по ссылке в переменных, названных по псевдониму соединения. Поскольку приложение — это собственный код сущности Release, переменные, которые эти агенты передают для чтения этим кодом, являются значениями по умолчанию: каждый их сокет допускает блок inject:, через который сущность Aggregate называет переменные или файлы, которые приложение читает вместо них, тогда как переменная, которую фреймворк читает сам, и то, что передаёт присоединение на соединении, остаются. То же относится к собственным значениям агента: каждый компонент допускает на себе блок inject: из записей env и file, и запись, шаблон которой читает одно из его собственных значений и ничего другого из компонента — ни другого значения, ни его infra, ни метаданных, ни идентичности, — заменяет имя по умолчанию, под которым сущность Recipe передаёт это значение, например CREWAI_ROLE для role агента CrewAI. Импорт объявлений агентов проекта CrewAI, файла langgraph.json приложения LangGraph, конфигураций агентов приложения Google ADK или декларативного агента Agent Framework создаёт черновики этих агентов — core/ai-agent/crewai, core/ai-agent/langgraph, core/ai-agent/google-adk и core/ai-agent/agent-framework, — подключённых к хранилищу данных, которое называет конфигурация, и к модели, которую она называет, там, где сокет model агента её принимает, рядом с черновиком сущности Release, который оставляет оператору указать образ, в котором работает программа, и читает только конфигурацию, никогда не программу, как описано в разделе Plugins импорта.

6. Топологическая валидация безопасности и принудительное применение во время выполнения

Поскольку AI-нагрузки приносят новые векторы атак (например, prompt injection и автономную утечку данных), их защита требует объединить статическое governance архитектуры с активным принудительным применением во время выполнения. Как компилятор Ahead-of-Time (AOT, предварительная компиляция), Aggrega не перехватывает живой сетевой трафик и не оценивает AI-промпты. Вместо этого он решает сложные требования безопасности через двухчастное архитектурное рукопожатие: статическую компиляцию архитектуры (во время компиляции) и передачу на выполнение (во время развёртывания).

A. Время компиляции: валидация политик и генерация артефактов

Компилятор строит плоский граф промежуточного представления (IR), содержащий все узлы, рёбра и присоединённые Features. Прежде чем будет сгенерирована какая-либо физическая инфраструктура, позиция безопасности предприятия обеспечивается оценкой этого статического JSON-графа отраслевыми стандартными движками политик в роли вердикта governance.

Поскольку сокет оценивает обобщённые JSON-данные, он не привязан к одному языку политик. Предприятия могут компилировать и применять свои архитектурные правила с помощью стандарта, который лучше всего подходит их экосистеме:

  • Open Policy Agent (OPA/Rego): широко используемый язык для оценки сложных многошаговых связей в графе и вычисления доступа с наименьшими привилегиями в распределённых топологиях. Движок Rego, встроенный в CLI, выполняет файлы .rego как есть; политика, которой нужен полный набор встроенных функций OPA, компилируется собственным инструментарием OPA и выполняется за гостем-адаптером.
  • Common Expression Language (CEL): движок CEL, встроенный в CLI, выполняет правила, записанные как одиночные выражения над документом, — так, как пишется политика validating-admission в Kubernetes.
  • Kyverno: оценивает статические манифесты JSON/YAML, позволяя командам писать политики на нативном YAML вместо изучения Rego. Компилятор не поставляется с гостем Kyverno: он выполняет политики только как гостей WebAssembly и никогда не вызывает Kyverno CLI, поэтому правила Kyverno выполняются за гостем, который оборачивает этот движок.
  • Собственная валидация на Rust/TypeScript: команды безопасности могут писать индивидуальные организационные политики на стандартных языках и компилировать их в Wasm, чтобы они служили шлюзом валидации.

Как только движок политик валидирует граф, компилятор преобразует эти абстрактные требования безопасности в физическую конфигурацию. Когда разработчик присоединяет Feature безопасности — например, core/data-masking на AI-gateway, — компилятор выполняет шаг конвейера, который называет её реализация, изолированный плагин WebAssembly (Wasm), и этот шаг записывает настройку, нужную мере контроля, в конфигурацию, которую уже генерирует собственный Recipe gateway. Реализация может вместо этого оставить запись собственному Recipe gateway, который читает присоединение и сам записывает настройку, как это делает core/data-masking на core/gateway/kong-enterprise, а реализация для другого типа контроля может выпускать собственный ресурс; в любом случае результатом является статический артефакт, записанный на основе того, что присоединил разработчик.

B. Время развёртывания и выполнения: передача на выполнение и принудительное применение

Ответственность Aggrega заканчивается ровно в тот момент, когда он завершает обработку входных данных и записывает настроенные статические артефакты в выходной каталог. Это чистый компилятор: он записывает конфигурацию, после чего управление полностью возвращается системе, которая его вызвала.

То, как эти конфигурации выполняются, очень гибко и полностью зависит от предприятия:

  • Передача артефактов (время развёртывания): внешние контроллеры развёртывания берут на себя воплощение артефактов в реальность. Это может быть строгий контроллер GitOps (например, ArgoCD или Flux), синхронизирующий файлы в кластер Kubernetes, но с тем же успехом это может быть стандартный конвейер CI/CD, выполняющий terraform apply, или разработчик, запускающий локальный shell-скрипт для Docker Compose.
  • Принудительное применение во время выполнения: как только конфигурации применены к целевой среде, дело переходит к физической инфраструктуре. Специализированные инструменты, настроенные Aggrega (например, sidecar с guardrails, активная service mesh или нативные облачные межсетевые экраны), запускаются и начинают свою активную работу: физически перехватывают полезные нагрузки, проверяют JWT или отбрасывают вредоносные prompt injection.

7. Как Aggrega подходит к проблемам безопасности AI

Отделив архитектурную валидацию от выполнения, команды платформы могут использовать Aggrega, чтобы явно моделировать, валидировать и генерировать конфигурационные решения для перечисленных ниже уязвимостей AI.

A. Утечка данных и перехват полезных нагрузок

  • Проблема: автономный агент может попытаться передать конфиденциальные корпоративные данные в неавторизованный внешний API.
  • Решение Aggrega:
    1. Время компиляции (валидация и генерация): команда платформы создаёт политику (например, на Rego), оцениваемую в роли вердикта governance и гласящую: «Каждый путь, проходящий через AI-gateway, должен нести core/data-masking.» Если его нет, компилятор останавливается. Если он есть, реализация, которую привязывает сущность Manifest, записывает маскирование в конфигурацию, которую gateway уже генерирует: на core/gateway/litellm — записи guardrail, соответствующие регулярным выражениям, перечисленным в присоединении, и отправляющие текст анализатору и анонимизатору Presidio, подключённым к сокетам pii_analyzer и pii_anonymizer gateway, для перечисленных типов сущностей; на core/gateway/kong-enterprise — AI PII Sanitizer от Kong на маршрутах chat и completion каждой подключённой модели, записанный Recipe чарта gateway, который отправляет маскируемый текст вместе с регулярными выражениями и типами сущностей, перечисленными в присоединении, в сервис Kong AI PII, подключённый к сокету pii_sanitizer gateway; на core/gateway/agentgateway — собственные охранники регулярных выражений gateway, записанные в его конфигурацию его Recipe чарта, которые заменяют каждое совпадение шаблонов, перечисленных в присоединении, на <masked> или в режиме refuse отвечают на запрос или ответ HTTP 403 и не распознают никаких типов сущностей; эти охранники не маскируют потоковый ответ, поэтому, пока ответы маскируются, тот же Recipe записывает правило, которое до пересылки отклоняет с HTTP 403 запрос, требующий такого ответа, а также любой запрос, тело которого превышает 2 MiB, читаемые gateway для этого правила, потоковый или нет; на core/gateway/traefik-hub — Content Guard AI-gateway Traefik Hub на маршруте каждой подключённой модели, записанный его Recipe чарта, который маскирует совпадения шаблонов, перечисленных в присоединении, через свой движок регулярных выражений или совпадения перечисленных типов сущностей через анализатор Presidio, подключённый к сокету pii_analyzer gateway, один движок на присоединение; на core/gateway/higress — плагин ai-data-masking от Higress на маршруте каждой подключённой модели, записанный его Recipe чарта, который заменяет каждое совпадение шаблонов, перечисленных в присоединении, в сообщениях chat-запроса именем шаблона в скобках и не распознаёт никаких типов сущностей. Политика может также задать более узкий вопрос — находится ли маскирование между конфиденциальными данными и поставщиком, — читая присоединения каждого компонента вдоль маршрута, а не присоединения маршрута в целом, как это делает examples/policy-data-class-route.
    2. Время выполнения (физическое применение): После того как оркестратор развернёт сгенерированные артефакты, шлюз перед пересылкой заменяет каждое совпадение в маскируемом им тексте запроса заполнителем, так что поставщик модели получает заполнитель; при action: refuse привязка не пересылает ничего из запроса, содержащего совпадение, а вместо этого отвечает на него ошибкой. Распознаватель, который недоступен или возвращает ошибку, приводит к сбою запроса, так что его текст не передаётся дальше. То, чего маскирование не достигает, определяют два значения, значения по умолчанию которых и являются защитой. На AI-шлюзе, когда привязка маскирует и ответы, шлюз маскирует текст ответа и части, которые модель или её поставщик добавляет рядом с ним, — отказ, цитаты и аннотации, запрос и результаты веб-поиска, поля с собственными именами поставщика — или, при refuse, не отправляет ничего из ответа, содержащего совпадение; потоковый ответ, который он маскирует по шаблонам, доходит до вызывающей стороны целиком, в конце. По умолчанию то, чего его маскирование не достигает в запросе, — маршрут, такой как генерация изображений, поле, такое как safety_identifier, изображение или файл в беседе, инструмент, который поставщик запускает сам, — AI-шлюз отклоняет с HTTP 400, прежде чем переслать что-либо из этого; оператор, который допускает, что такой текст дойдёт до поставщика незамаскированным, задаёт allow_unmasked_text на привязке в сущности Release, причём реализация точно перечисляет, что тогда проходит, а содержимое, не являющееся текстом, по-прежнему регулируется allow_non_text_content. По умолчанию то, что содержит замаскированный ответ и что его маскирование не может прочитать, — устное аудио и его расшифровка, изображение, вероятности токенов, выбранных моделью, — удерживается, а неудавшийся вызов доходит до вызывающей стороны с фиксированным сообщением вместо того, которое вернул поставщик; allow_unmasked_reply_parts позволяет этим частям доходить до вызывающей стороны незамаскированными. Собственный текст ответа этим значением никогда не пропускается, но части, которые оно пропускает, могут содержать слова ответа: расшифровку устного ответа, токены за вероятностями токенов, сообщение об ошибке поставщика, цитирующее ответ. На core/gateway/kong-enterprise каждое совпадение заменяется нумерованным заполнителем, поэтому привязка, перечисляющая шаблоны в redact, задаёт placeholder_shows_name: false; refuse охватывает только запросы, начиная с Kong 3.12, который отвечает на запрос с совпадением кодом HTTP 400; а ответы маскируются начиная с 3.12, причём запрос потокового ответа тогда отклоняется до пересылки, а allow_streamed_replies отклоняется. Sanitizer Kong читает текст реплик пользователя, prompt completion и текст сообщения ответа, а справочник Kong не называет ни одного параметра, который отклонял бы запрос из-за того, что sanitizer не читает, или удерживал остаток ответа, поэтому на этом шлюзе каждая защита отклоняется по имени во время сборки, пока сохраняет значение по умолчанию, а привязка собирается, как только сущность Release их ослабит, — allow_unmasked_text и allow_non_text_content там, где маскируются запросы, allow_unmasked_reply_parts и mask_reasoning: false там, где маскируются ответы, — при этом data-masking-kong-enterprise перечисляет, что каждая тогда пропускает. Там ответ, текст которого приходит не в виде единой строки, возвращаемой OpenAI API, проходит непрочитанным, и его собственный текст доходит до вызывающей стороны незамаскированным; защитой от этого служит проверка, которую сборка выполняет для каждой модели, подключённой к этому шлюзу, и которая останавливается на модели, чей model.aggrega.ai/api не равен openai. На core/gateway/traefik-hub каждое совпадение заменяется последовательностью * длиной с совпадение, поэтому привязка, перечисляющая шаблоны в redact, задаёт placeholder_shows_name: false; refuse отвечает HTTP 403 вместо запроса или ответа; а замаскированный ответ удерживается целиком и отправляется в конце, включая потоковый, поэтому привязка, маскирующая типы сущностей в ответах, задаёт allow_streamed_replies. Справочник Traefik не говорит, какие поля запроса или ответа чата читает Content Guard, и не называет ни одного параметра, который отклонял бы запрос или удерживал часть ответа из-за того, что он не читает, поэтому на этом шлюзе каждая защита отклоняется по имени во время сборки, пока сохраняет значение по умолчанию, а привязка собирается, как только сущность Release их ослабит, — allow_unmasked_text и allow_non_text_content там, где маскируются запросы, allow_unmasked_reply_parts и mask_reasoning: false там, где маскируются ответы, — при этом data-masking-traefik-hub перечисляет, что каждая тогда пропускает. Привязка, перечисляющая и шаблоны, и типы сущностей, а также вторая привязка маскирования на одном шлюзе отклоняются, поскольку справочник Traefik не говорит, читает ли второй Content Guard на маршруте текст, замаскированный первым, или запрос в том виде, в каком его отправила вызывающая сторона. На core/gateway/higress плагин Higress ai-data-masking заменяет каждое совпадение шаблонов, перечисленных привязкой, в содержимом и рассуждениях каждого сообщения запроса чата именем шаблона в квадратных скобках; он маскирует только запросы, поэтому scope response и both отклоняются, и он не распознаёт никаких типов сущностей. Плагин больше ничего не читает из запроса, поэтому, пока защиты сохраняют значения по умолчанию, Recipe чарта шлюза также прописывает плагин проверки запросов Higress, чтобы отклонять с HTTP 403, прежде чем что-либо будет переслано, запрос, содержащий то, чего маскирование не читает, — тело, отправленное не как JSON или не являющееся chat completion, сообщение, содержимое которого — список или null, вызов инструмента или реплику инструмента, имя сообщения, любой параметр, кроме нетекстовых параметров chat completion и собственных инструментов, формата ответа и стоп-последовательностей разработчика, — а также, что бы ни ослабляла привязка, запрос, тело которого плагины Higress пропускают, — сжатое тело, тип содержимого, содержащий octet-stream или grpc, upgrade, — и тело, содержащее символ замены Unicode U+FFFD, которым эта проверка читает байт, не являющийся корректным UTF-8, поскольку плагин маскирования пересылает тело, не являющееся корректным UTF-8, незамаскированным. Запрос, тело которого превышает буфер шлюза объёмом 32 KiB, отклоняется с HTTP 413. Проверка читает только тело, которое принимает её декодер JSON, поэтому клиент, намеренно отправляющий корректный JSON, который декодер отклоняет, — например, число за пределами того, что вмещает double, — проходит через каждое отклонение своего тела: плагин маскирования тогда маскирует только простое содержимое и рассуждения каждого сообщения, поэтому перечисленное значение в любом другом месте тела — аргументы вызова инструмента, имя, любое другое поле — пересылается незамаскированным, как и содержимое, записанное с помощью escape-последовательностей JSON, а если такое тело к тому же не является корректным UTF-8, оно пересылается незамаскированным целиком. Клиент, намеренно вкладывающий тело на глубину более 127 уровней внутри поля, которое проверка допускает, например tools, отправляет корректный JSON, который проверка декодирует и допускает, но JSON-читатель плагина маскирования останавливается на этой глубине, поэтому содержимое, записанное с помощью escape-последовательностей JSON в таком теле, также пересылается незамаскированным. Одного маскирования недостаточно: текст, которому не соответствует ни один шаблон и который не обнаруживает ни один распознаватель, проходит без изменений; на AI-шлюзе аргументы вызовов инструментов и результаты инструментов маскируются значение за значением, но имена их ключей — нет; собственные определения инструментов, форматы ответа и стоп-последовательности разработчика проходят в отправленном виде; шлюз и службы распознавания видят исходный текст; то, что шлюз записывает о вызове, — в собственном журнале или в том, что он передаёт интеграции журналирования, — всё ещё может содержать этот текст; а трафик, не проходящий через шлюз, не затрагивается.

B. Защита от отравления MCP (доверие и изоляция)

  • Проблема: Если агент скомпрометирован через отравленный инструмент Model Context Protocol (MCP), он может автономно выполнять разрушительные действия (например, удалить базу данных или авторизовать перевод).
  • Решение Aggrega:
    1. Время компиляции (проверка и генерация): Разработчик привязывает Feature шлюза одобрения к чувствительному инструменту в своём Aggregate.yaml. Стандартная библиотека не поставляет такой Feature, поэтому её создают в собственном каталоге предприятия вместе с FeatureRecipe, которая её рендерит. Компилятор проверяет граф и преобразует привязку в конфигурацию для прокси L7 или webhook-шлюза.
    2. Время выполнения (физическое применение): Когда захваченный агент пытается вызвать инструмент, развёрнутый прокси приостанавливает запрос и физически блокирует выполнение, пока не получит криптографически подписанное одобрение от оператора-человека.

C. Решение проблемы «Confused Deputy» (распространение контекста)

  • Проблема: В многоагентных цепочках общедоступный агент может быть захвачен и приказать внутреннему агенту с высокими привилегиями получить конфиденциальные данные. Стандартные межсетевые экраны видят лишь, что «агент A общается с агентом B», и пропускают трафик, полностью теряя контекст исходного злонамеренного пользователя.
  • Решение Aggrega: Предприятия могут сочетать два конкретных паттерна:
    1. Распространение идентичности вызывающей стороны на двух переходах: Идентичность исходной вызывающей стороны должна пережить два разных перехода, и каждый защищается в своём месте. На переходе через шлюз разработчик привязывает core/context-propagation, которая выбирает по dataplane.aggrega.ai/caller-identity, к шлюзу, через который входит запрос. Во время компиляции привязка реализуется в собственной конфигурации этого шлюза — на Envoy Gateway в виде client traffic policy, которая проверяет сертификат каждого клиента по центру сертификации, указанному сущностью Release, и пересылает сведения о сертификате; на AI-шлюзе LiteLLM в виде хука запросов, который удаляет любой заголовок идентичности, переданный вызывающей стороной, и добавляет пользователя и команду виртуального ключа, проверенного шлюзом, а также его организацию, если ключ её указывает, в запросы к псевдонимам моделей, которые привязка перечисляет в destinations. Во время выполнения служба за шлюзом получает, кто вызвал, а не только то, что вызвал шлюз. На переходе между рабочими нагрузками запрос, который один агент делает напрямую другому, никогда не проходит через этот шлюз, поэтому он проверяется на собственном ingress принимающего агента, где service mesh отклоняет любой запрос без подписанного токена, подтверждающего намерение исходного пользователя (например, Istio JWT AuthorizationPolicy). Стандартная библиотека поставляет Feature для перехода через шлюз и ни одной Feature для перехода между рабочими нагрузками, поэтому привязка core/context-propagation защищает трафик, проходящий через шлюз, а вызовы между агентами оставляет конфигурации mesh, которую предприятие предоставляет само. Агент, которого запускает другая сторона и к которому core/ai-tool/agent-invocation обращается по A2A как к core/ai-agent/a2a-remote, находится полностью вне сущности Release: эта сторона проверяет каждый вызов по схеме безопасности, которую объявляет Agent Card агента, а инструмент предъявляет учётные данные, хранящиеся в его соединении и считываемые по ссылке из Secret, в заголовке запроса, который публикует агент. Когда карточка требует client credentials OAuth 2.0 или OpenID Connect, соединение хранит вместо этого или в дополнение client secret вместе с client id, который на нём записывает оператор, а агент публикует адрес токена или discovery и scopes, которые объявляет его карточка; собственный контейнер инструмента получает с их помощью токен, обновляет его и предъявляет при каждом вызове; каталог поставляет только эти входные данные, и никакая сборка не может проверить, что контейнер с ними делает. Когда карточка требует взаимного TLS, соединение хранит клиентский сертификат, а если серверный сертификат агента подписан центром сертификации, которому образ ещё не доверяет, — и этот центр; каждый монтируется в контейнер инструмента как файлы из Secret, указанного соединением, и контейнер сам предъявляет сертификат при рукопожатии TLS. Итак, инструмент обращается к агенту, карточка которого объявляет ключ API в заголовке или cookie, схему аутентификации HTTP с фиксированным значением, такую как Bearer или Basic, где Secret содержит всё значение заголовка, OAuth 2.0 или OpenID Connect с grant client-credentials либо взаимный TLS. Он не обращается к агенту, карточка которого требует ключ в строке запроса, схему HTTP, отвечающую на challenge от агента, такую как Digest, или поток OAuth 2.0, отличный от client credentials. Не предъявляет он учётных данных и агенту, которого другая сторона запускает по обычному HTTP: когда адрес этого агента — http, учётные данные или client secret на соединении останавливают сборку с указанием соединения, поскольку учётные данные или токен, полученный с помощью secret, передавались бы ему незашифрованными. Агент, работающий внутри сущности Release, остаётся доступным по http с любым из них, и учётные данные тогда проходят по сети кластера незашифрованными.
    2. Проверка payload между агентами: Запрос, который один агент отправляет напрямую другому, никогда не проходит через AI-шлюз, поэтому он проверяется на собственном ingress принимающего агента движком guardrails, работающим рядом с этим агентом (например, NeMo Guardrails). Во время компиляции FeatureRecipe, реализующая Feature, привязанную к принимающему агенту, рендерит конфигурацию движка. Во время выполнения движок оценивает каждый запрос по правилам, которые пишет предприятие, и отклоняет тот, который эти правила отвергают; насколько хорошо он отличает захваченный запрос от легитимного, зависит от движка и правил, поскольку Aggrega компилирует конфигурацию и никогда не оценивает prompt. Стандартная библиотека не поставляет ни одной Feature, которая размещала бы такой движок, поэтому этот паттерн создаётся в собственном каталоге предприятия. Собственная шаблонная защита шлюза, dataplane.aggrega.ai/prompt-guard: pattern-list, уже, и core/prompt-deny-patterns включает её — на AI-шлюзе читается каждое сообщение запроса, а регистр букв игнорируется, на core/gateway/apisix и core/gateway/kong каждое сообщение каждой роли читается как один текст, регистр букв учитывается и соблюдается также список шаблонов, которым запрос должен соответствовать, на core/gateway/agentgateway каждое сообщение, аргумент вызова инструмента и результат инструмента читаются по отдельности, регистр букв учитывается, а на core/gateway/traefik-hub запрос читается как chat completion, читаемые поля которой справочник Traefik не перечисляет, регистр букв учитывается: она отклоняет запрос к модели, текст которого буквально соответствует одному из выражений, перечисленных привязкой, — перефразирование, другой язык или кодирование её обходят — и только в трафике, проходящем через шлюз, поэтому запрос, отправленный напрямую между агентами, никогда с ней не сталкивается. core/prompt-injection-shield — её аналог на основе классификатора на том же переходе, отправляющий каждый запрос к модели, который пересылает шлюз, через защитника NeMo Guardrails, подключённого к сокету guard этого шлюза, или через prompt shield Azure AI Content Safety в Azure API Management, и он тоже охватывает только трафик, проходящий через шлюз.

D. Топологический анализ рисков

  • Проблема: Сложные архитектуры ИИ с десятками взаимосвязанных моделей, векторов и инструментов слишком масштабны, чтобы человек мог вручную проверить их на транзитивные уязвимости (например, «Может ли агент A общаться с инструментом B, который общается с агентом C, у которого есть доступ к базе данных D?»).
  • Решение Aggrega: Эта проверка выполняется заранее. Поскольку Aggrega строит в памяти полный граф IR предполагаемой топологии, роль вердикта governance может запускать продвинутые правила поиска путей по всей архитектуре. Если политика обнаруживает непрерывную транзитивную цепочку рёбер, начинающуюся в публичном узле и заканчивающуюся в высокочувствительной базе данных, вдоль которой нигде не привязан ни один из контролей, требуемых предприятием, она немедленно останавливает сборку. Небезопасная архитектура блокируется ещё до того, как будет сгенерирована хотя бы одна строка инфраструктурного кода.

8. Наблюдаемость и соответствие требованиям

Чтобы удовлетворить строгим нормативным требованиям (например, Регламенту ЕС об ИИ — EU AI Act), архитекторы платформы могут использовать систему функций Aggrega, чтобы обеспечивать наблюдаемость ИИ как структурное требование к инфраструктуре, а не полагаться на код приложения:

  • Журналирование аудита: Wasm-плагины, созданные предприятием, могут настраивать sidecar-контейнеры шлюза на асинхронную потоковую передачу необработанных, нередактированных промптов и ответов в защищённое хранилище WORM (Write Once, Read Many — однократная запись, многократное чтение), минуя стандартные журналы приложения.
  • Трассировка LLM: Функции прокси могут настраивать плоскость данных на извлечение и пересылку специфичных для ИИ заголовков спанов OpenTelemetry, обеспечивая возможность визуализировать сложные циклы рассуждений агентов во внешних инструментах.

9. Совместимость Feature и топологическая безопасность

Поскольку ядро компилятора агностично по отношению к механике физической инфраструктуры, оно полностью полагается на явные объявления в каталоге, чтобы предотвратить генерацию несовместимых конфигураций.

  • conflictsWith: Список, объявляемый в сущности каталога Feature в разделе interoperability, тех Features, вместе с которыми её нельзя прикрепить. Компилятор сравнивает его с Features, которые в итоге несёт каждый компонент после того, как свой вклад внесли все области, — собственные прикрепления компонента, прикрепления, записанные в подсистеме или границе, которая его содержит, прикрепления в записи компонента в его Release и прикрепления, созданные расширением на основе аннотаций, — и останавливается до рендеринга каких-либо физических артефактов, если один компонент несёт обе (т. е. автор прикрепляет, напрямую или через область, две Features, которые автор одной из них явно объявил несовместимыми). Достаточно одного объявления, и Features сопоставляются по имени независимо от их версий. Компилятор не вкладывает в имена никакого смысла: несовместимость — это объявление автора, а проверка — это сравнение имён. Атомарность и чистота самих Features остаются общественным договором — ничто не проверяет, что Feature делает что-то одно.

10. Динамическое отображение топологии (разрешение зависимостей)

Чтобы построить граф IR без жёстко заданных правил, компилятор считывает его из трёх явных объявлений:

  • Рёбра uses: разработчики связывают компоненты в блоке uses каждого экземпляра, называя целевой компонент в сокете, и каждое ребро графа происходит из такого блока. Запись values, в которой случайно названо имя другого компонента, не проводит ребра: компилятор не вкладывает в значение никакого смысла.
  • Цели рёбер: каждая цель uses должна называть компонент, который есть в сборке; несуществующая цель останавливает сборку с указанием сокета, к которому она была подключена.
  • Типобезопасность между узлами: Строки селекторов usesSchema служат явными внеполосными инструкциями, которые нативно вычисляются механизмом сопоставления меток компилятора Go во время статического анализа. Они гарантируют, что разработчики не смогут случайно подключить стандартные компоненты к объявленному сокету, который требует конкретной ИИ-нативной возможности или метки соответствия требованиям. Гарантия по построению ограничена объявленными сокетами: селектор находится в записи usesSchema, поэтому у ad-hoc сокета нет селектора, который можно было бы вычислить. Каждое ребро фиксирует, был ли его сокет объявлен в каталоге, поэтому оператор, которому нужна полная гарантия, может потребовать её в виде вердикта управления.

11. Автоматизированное проектирование агентных систем (ADAS)

Продвинутые системы ИИ включают мета-агентов, которые пишут код, чтобы изобретать и развёртывать новых агентов на лету. Поскольку Aggrega требует статической архитектуры, определяемой заранее (ahead-of-time, AOT), она решает задачу эволюции инфраструктуры во время выполнения с помощью двух явных границ:

  • Граница заранее подготовленной песочницы: Для эфемерных инструментов, изобретённых во время выполнения, архитектор определяет функцию (например, dynamic-execution-environment). Когда она прикреплена, Wasm-плагин рендеринга генерирует конфигурацию для подготовки изолированного вычислительного пула (например, среды выполнения WebAssembly). Мета-агент внедряет новый код в эту песочницу, но радиус поражения ограничен сгенерированными статическими сетевыми политиками.
  • Мета-агент в роли «разработчика» (цикл GitOps): Если мета-агенту нужна действительно новая физическая инфраструктура, он действует как разработчик. Он пишет новый Aggregate.yaml и фиксирует его в Git. Это запускает стандартный конвейер CI/CD. Роль вердикта управления статически анализирует запрошенную ИИ топологию и безопасно останавливает сборку, если ИИ сгаллюцинировал уязвимость.

12. Сериализация моделей и безопасность цепочки поставок

Развёртывание модели с открытым исходным кодом часто означает загрузку непрозрачных файлов .pkl или .gguf, которые могут содержать вредоносный код. Предприятия могут рассматривать безопасность цепочки поставок моделей как задачу конфигурации целевой платформы. Определив функцию model_provenance в каталоге, Wasm-плагин рендеринга предприятия может вычислить конфигурацию и преобразовать её в артефакты времени выполнения (например, политики Kyverno для Kubernetes), так что целевой кластер настраивается блокировать загрузку оркестратором неподписанных или непроверенных весов модели.