Комплексный серверный фреймворк для Java и Kotlin
Kora строит граф приложения во время компиляции, генерирует высокопроизводительный исходный код и сразу готова к использованию в облачно-ориентированной среде как простой, понятный, эффективный и уже знакомый стек на JVM.
Процесс разработки STEP для стажеров, инженеров и нейро-агентов: просто, прозрачно, эффективно и предсказуемо.
Знакомые модули, клиенты, репозитории и контроллеры используют прямой синхронный код на Java и Kotlin с типизированными контрактами и генерацией реализаций. Те же подходы работают для HTTP, OpenAPI, gRPC, данных, обмена сообщениями, отказоустойчивости и конфигурации — ваш опыт JVM-разработки применим во всём стеке.
Откройте сгенерированный код и проследите реальный путь выполнения: от связывания зависимостей до обработки запросов и обращений к базе данных. Заменяйте стандартные компоненты, меняйте поведение и добавляйте интеграции через явные типизированные контракты — без борьбы с фреймворком и разгадывания скрытых механизмов выполнения.
Явный код, документация по конкретным задачам, запускаемые примеры и официальный Kora нейро-навык снижают когнитивную нагрузку: меньше правил и контекста фреймворка приходится держать в голове. Инженеры и нейро-агенты работают шаг за шагом, используя точную диагностику компилятора и быстрые тесты, чтобы изучать, создавать, проверять и улучшать сервисы.
Оптимизации уже сделаны: разработчикам не нужно тратить время на тюнинг фреймворка и держать в голове хаки производительности. Низкое потребление CPU и памяти, быстрый запуск, отказоустойчивость, корректное завершение, а также метрики и трассировка OTel во всех модулях поддерживают стабильную, предсказуемую и наблюдаемую работу сервисов.
TechEmpower Single query (external): число ответов в секунду при одном запросе к базе данных на HTTP-запрос. Чем больше, тем лучше.
Для одного сервиса чистая производительность редко является целью — большинство сервисов спокойно держат свою нагрузку на любом фреймворке, поэтому легко сделать вывод, что эффективность здесь неважна. Для одного сервиса в отрыве от остального это действительно так.
Инженеры часто видят систему только со своей колокольни — свой сервис, свой репозиторий, своя машина, в лучшем случае свой продакшн-стенд — и через эту призму вывод выглядит верным. Но поднимитесь на уровень всей технической инфраструктуры компании — и картина, а вместе с ней и приоритеты, выглядят совсем иначе.
Потому что ничто не работает в единственном экземпляре. Боевой сервис по умолчанию резервируется: минимум два инстанса на дата-центр, чтобы плавный деплой или потеря узла никогда не роняли сервис, и обычно второй дата-центр для отказоустойчивости между регионами — ещё два инстанса. Это четыре и более работающих копии каждого сервиса ещё до того, как придёт хотя бы один реальный пользователь.
Именно здесь потребление на экземпляр перестаёт быть про скорость и становится про деньги. Более тяжёлый рантайм резервирует больше памяти и CPU только для того, чтобы стартовать и оставаться здоровым за разумное время, — это запас, за который вы платите на каждой резервной копии, независимо от того, делает она полезную работу или нет.
Всё дело в масштабе. Возьмите этот один сервис и размножьте его: пара инстансов для резервирования, затем на два дата-центра, затем каждый сервис команды, затем каждая команда в департаменте, затем каждый департамент в бизнес-линии, затем каждая бизнес-линия в компании — и вдобавок ко всему запас CPU и RAM, зарезервированный под пиковые события вроде «чёрной пятницы». А эксплуатация инфраструктуры такого масштаба — это совсем не то же самое, что купить процессор или ПК для локальной работы: каждое зарезервированное ядро и гигабайт несёт свою долю расходов на инженеров эксплуатации на местах, серверные стойки, электричество, охлаждение, сеть и прочие накладные расходы дата-центра, оплачиваемые каждый месяц. Разница на один инстанс, казавшаяся незначительной, теперь умножена на десятки тысяч. Более лёгкий рантайм вроде Kora превращает производительность, которая вам была не нужна, в зарезервированные память и CPU, за которые вы просто перестаёте платить, — та же надёжность, но на значительно меньшем числе ядер.
Цифры приведены для иллюстрации, а не измерены — реальные значения зависят от ваших сервисов, настроек JVM, SLA, пикового запаса и цен облака. Важна форма: потребление × резервирование × сервисы × команды × департаменты × бизнес-линии × пиковый резерв.
Kora не стремится к охвату ради охвата, не оборачивает каждую технологию в собственную абстракцию и не заменяет собой всю функциональность других фреймворков и библиотек. Она берет проверенные, широко используемые практики серверной разработки и доводит их до предела: меньше механики во время выполнения, меньше конкурирующих стилей, понятнее контракты и ниже когнитивная нагрузка.
Швейцарский нож предлагает инструмент почти на любой случай, но редко делает всё одинаково хорошо. Kora делает ставку на точечный набор инструментов, которые заточены под свои задачи.
Используйте только нужные вам модули, заменяйте или настраивайте их компоненты и добавляйте свои модули и интеграции через ту же явную модель приложения.
Kora сосредоточена на главном в промышленной серверной разработке и делает этот путь исключительно прямым, прозрачным и максимально эффективным.
Kora просто работает.
Просто. Прозрачно. Предсказуемо. Эффективно.
Такие же подходы делают Kora проще для разработки, отладки и поддержки инженерами: компоненты связываются явно, ошибки компилятор ловит как понятные сообщения вместо сюрпризов во время выполнения, а каждый сгенерированный класс читается как код, который инженер написал бы сам. Та же ясность делает Kora естественной и для разработки с участием нейро-агентов — ничего не скрыто за рефлексией, динамическими прокси или байт-кодом, поэтому нейро-агент может открыть сгенерированные исходники, проследить запрос от начала до конца и доверять увиденному так же легко, как человек.
Разработка Шаг за Шагом — для инженеров и нейро-агентов.
95%+ функциональности Kora описано в документации: пошаговых руководствах, справочниках по модулям и рабочих примерах. Не нужно угадывать, про какую версию ответила нейросеть, собирать ответы по десяткам вкладок и разрозненным обсуждениям на Stack Overflow. А официальный нейро-навык kora-skills делает работу с Kora еще проще для нейро-агентов.
Учиться Kora сегодня можно просто: установите официальный навык kora-skills и задайте вопрос своему агенту — он сверяется с навыком и объясняет прямо по официальным руководствам и примерам.
Начинайте с малого, добавляйте только те интеграции, которые нужны сервису, и держите каждую зависимость под контролем.
Компоненты, внедрение через конструктор, модули, типизированная конфигурация и запуск приложения на привычных Java и Kotlin. Подход virtual-thread-first: прямой синхронный код без реактивных цепочек и колбэков.
Связывание проверяется и генерируется во время компиляции, поэтому ошибки становятся понятными сообщениями компилятора, а не сюрпризами во время выполнения — явный типизированный код с быстрым циклом обратной связи как для инженеров, так и для нейросетей.
HTTP-серверы, декларативные клиенты, request mapping, interceptors, служебные эндпоинты и строго типизированная генерация OpenAPI. Spec-first подход: серверы и клиенты создаются из OpenAPI-контракта строго типизированным генератором с богатыми настройками.
Единая модель репозиториев для JDBC и Cassandra: сгенерированные реализации, преобразования во время компиляции, макросы запросов и явный контроль над доступом к данным.
Обмен сообщениями, RPC, хранилища, движки бизнес-процессов и инфраструктурные интеграции, построенные вокруг той же явной модели программирования.
Проверка данных, кэширование, отказоустойчивость, транзакции, планирование, безопасность и логирование генерируются во время компиляции без прокси-объектов времени выполнения.
Метрики и трассировка OTel во всех модулях, структурированное логирование, распространение контекста, проверки работоспособности и корректное завершение встроены с самого начала.
Почти любой компонент можно заменить, обернуть или дополнить и адаптировать поведение фреймворка через явный граф приложения, создаваемый во время компиляции.
Kora держит HTTP-контракты явными, сгенерированными и наблюдаемыми, не пряча обработку запросов за рефлексией во время выполнения.
Что вы получаетеЯвный код, строгие типы, точная обратная связь компилятора и почти полное отсутствие магии — те же качества, что делают код понятным для новичка в команде, делают его посильным и для нейро-агента. Kora привносит эти качества в Java и Kotlin, поэтому разрабатывать сервисы становится удобнее как человеку, так и с помощью новых нейро-инструментов.
Настоящий цикл итераций: агент пишет код, компилятор отвечает, агент исправляет и идёт дальше — большинство ошибок ловится ещё до запуска.
Kora позволяет очень быстро проверять каждое изменение на двух уровнях. Сначала внедрение зависимостей на этапе компиляции, обработчики аннотаций и типизация ловят структурные ошибки ещё при сборке. Затем благодаря очень быстрому старту контекста приложения можно дёшево и часто запускать полноценные компонентные и интеграционные тесты. Цикл остаётся коротким: изменил → скомпилировал → получил точные ошибки → поднял контекст → проверил реальное поведение → исправил. Чем короче такой цикл, тем быстрее новичок разбирается в проекте и тем эффективнее работает автономный агент.
Внедрение зависимостей, HTTP-обработчики, репозитории, AOP и остальная инфраструктура Kora превращаются в обычный код на Java и Kotlin. Сгенерированный исходный код можно открыть, прочитать и проследить реальный путь выполнения. Меньше рефлексии, динамических прокси и скрытого поведения — меньше того, что нужно держать в голове или угадывать нейросети. А поскольку весь путь прозрачен и ведёт напрямую, его легко проследить и отладить — можно просто попросить нейросеть объяснить, как отсюда работает вся цепочка, и она разберёт её по реальному коду.
Java и Kotlin вместе с внедрением зависимостей на этапе компиляции дают чётко определённые внутренние контракты, а OpenAPI Generator в Kora распространяет этот подход и на внешнее API: строго типизированные серверные и клиентские API, модели, параметры, запросы и ответы. Ошибочное предположение скорее превратится в ошибку компиляции, чем в ошибку во время выполнения.
Конструкторы, интерфейсы, @Component, @Module и @KoraApp прямо в исходном коде описывают граф приложения. Проще увидеть, что от чего зависит, где создаётся компонент и какой контракт он реализует, — не восстанавливая в голове состояние контейнера во время выполнения.
Небольшой набор прямых и независимых абстракций сужает пространство возможных решений. Это одинаково важно и для новичка, и для нейросети: меньше шансов смешать разные поколения API, модели программирования и несовместимые подходы фреймворков.
Kora старается держаться близко к JDBC, Kafka, gRPC, HTTP и другим базовым технологиям, а не строить отдельный мир вокруг фреймворка. Это привычные большинству Java-разработчиков абстракции, которые годами работают в промышленной эксплуатации и знакомы всем. Поэтому почти всё, что вы — или модель — уже знаете о Java, Kotlin и стандартных технологиях, напрямую применимо к коду на Kora.
Явность, прозрачность, строгая типизация, точная обратная связь компилятора и минимум магии делают Kora понятной инженеру, который приходит в проект, и предсказуемой для его инструментов.
Быстрая готовность помогает горизонтальному масштабированию лучше справляться с пиковой нагрузкой, а тонкий слой фреймворка до бизнес кода снижает стартовые просадки SLA во время развертываний. (Меньше значит лучше.)
Время старта и выхода в готовность воспринимается как локальная эргономика разработчика. В масштабах парка сервисов это операционный драйвер затрат — и в выделяемой инфраструктуре, и во времени инженеров.
Задержка p95 во время плавного деплоя. Свежий экземпляр Kora выходит на установившуюся задержку почти сразу; более тяжёлый рантайм дольше удерживает повышенный хвост выше порога SLA, пока прогревается JIT.
Секунды на экземпляр × весь парк × каждый перезапуск → меньше машин, меньший счёт и более быстрый цикл. Kora строит граф во время компиляции, а на старте всё инициализируется максимально параллельно, насколько возможно, и имеет значительно меньший след прогрева.
Базовые принципы инженерных решений Kora делают сервисы прозрачными, быстрыми на старте и простыми в поддержке.
Контейнер зависимостей строится и проверяется во время компиляции из объявлений @KoraApp, @Component, @Module и подмодулей. Отсутствующие или неоднозначные зависимости становятся ошибкой еще до старта сервиса.
Kora не использует Reflection API, динамические прокси и генерацию байткода во время выполнения для графа приложения. Вместо этого появляется читаемый исходный код, который может изучать, поддерживать, отлаживать и проверять человек или нейросеть
Kora использует тщательно выбранные, быстрые и оптимизированные интеграции и просит включать только те модули, которые нужны сервису. Командам не нужно заранее исследовать, какой веб-сервер, HTTP-клиент, подход к базе данных, Redis-клиент или интеграцию с очередями сделать внутренним стандартом.
Kora использует нативные конструкции Java и Kotlin для объявления механизмов фреймворка и не заставляет разработчиков переходить на чужеродную модель программирования. HTTP-обработчики, слушатели Kafka, репозитории, интерфейсы конфигурации и аспекты выглядят естественно в языке, которым вы уже пользуетесь, а генерация во время компиляции забирает на себя повторяющуюся работу.
Читаемые сгенерированные исходники, ошибки на этапе компиляции, сфокусированная документация и примеры упрощают погружение в проект. Новые разработчики могут посмотреть, что сделал фреймворк, быстро проверить поведение и попросить нейросеть пройтись по реальному коду вместо угадывания скрытого состояния во время выполнения.
Фреймворки, завязанные на прокси, могут казаться простыми, пока поведение не начинает зависеть от скрытых правил прокси во время выполнения, самовызовов методов, рефлексии или контейнерных соглашений, которые меняются от версии к версии. Kora держит механизм прозрачным: сгенерированный код и документация хранят контекст, поэтому разработчикам не нужно заучивать фольклор вокруг аннотаций или держать невидимое состояние фреймворка в голове.
Kora с первого запроса опирается на оптимизации для высоких нагрузок, проверенные в промышленной эксплуатации: быстрый запуск, явные графы зависимостей, сгенерированные адаптеры и легкие модульные интеграции. Разработчикам не нужно читать сотни статей, смотреть сотни докладов, тратить тысячи часов на замеры производительности внутренностей фреймворка или настраивать сам фреймворк перед выпуском. Это уже сделано внутри Kora. Просто начинайте писать сервисы.
Kora предпочитает одно рекомендуемое решение на базе лучших практик JVM вместо множества конкурирующих стилей внутри одного фреймворка. Команды тратят меньше времени на внутренние правила, доклады о правильном использовании и споры о том, какую абстракцию разрешить.
Вам не нужно огромное сообщество, чтобы разобраться, как работает фреймворк. Не нужно искать ответы среди тысяч обсуждений, сверять противоречивые советы, смотреть десятки докладов или выяснять, почему реальное поведение отличается от документации. Kora просто работает. Документация соответствует реализации, примеры отражают реальные практики, сгенерированный код остаётся читаемым, а нейросеть может объяснить, что происходит внутри, потому что механизмы фреймворка открыты и прозрачны.
Тестируйте сервис через тот же явный граф компонентов, который используется в промышленной эксплуатации. Подставляйте тестовые компоненты, заменяйте зависимости, переопределяйте конфигурацию, держите компонентные тесты быстрыми и добавляйте интеграционные тесты на Testcontainers там, где нужна реальная инфраструктура.
Трассировка, метрики, структурированное логирование, проверки работоспособности, отказоустойчивость и корректное завершение для всех модулей спроектированы как возможности фреймворка, а не поздние надстройки. Эксплуатационный контракт остается видимым в сгенерированном и написанном вручную коде.
Пройдите пошаговую настройку, используйте официальные примеры или сразу откройте документацию по модулям для стека, который вам уже нужен.