Asya

Asya — это акторный фреймворк для оркестрации AI/ML, родной для Kubernetes. Получите независимое масштабирование для Python, динамические пайплайны и автоскалинг KEDA для экономии затрат.

Data Science и ML Облачная инфраструктура Деплой и DevOps ★ 21 GitHub (21 ★)

Asya — это нативный для Kubernetes, основанный на очередях фреймворк асинхронных акторов, предназначенный для оркестрации AI/ML рабочих нагрузок в масштабе. Он позволяет специалистам по данным писать чистые функции Python, абстрагируясь от проблем нижележащей инфраструктуры, таких как очереди, маршрутизация, масштабирование и мониторинг. Используя паттерн Sidecar и автомасштабирование KEDA, Asya обеспечивает независимое масштабирование каждого актора от нуля до N на основе глубины очереди, обеспечивая значительную экономическую эффективность и возможности динамических конвейеров, идеально подходящих для многоэтапных AI-рабочих процессов и обработки, управляемой событиями.

Ключевые особенности

01Экономия затрат за счет автомасштабирования KEDA с нуля

02Независимое масштабирование каждого актора на основе глубины очереди

03Нулевой код инфраструктуры для обработчиков чистых функций Python

04Динамические конвейеры с изменяемыми во время выполнения маршрутами, управляемыми данными

05Паттерн Sidecar для надежной маршрутизации сообщений, повторных попыток и потребления из очереди

0621 звезда на GitHub

Варианты использования

01Оркестрация многоэтапных конвейеров AI/ML (например, обработка LLM, изображений, документов)

02Обработка событийно-ориентированных нагрузок, таких как обработка вебхуков и асинхронные бэкенды API

03Управление чувствительными к затратам развертываниями, требующими вывода GPU или пикового трафика

Asya🎭

/ˈɑːsjə/, from Async Actors

Asya🎭 is a queue-based actor framework for orchestrating AI/ML workloads on Kubernetes with:

Independent scaling: Each actor scales 0→N based on its own queue depth
Zero infrastructure code: Pure Python functions, no dependencies for queues/routing/retries
Dynamic pipelines: Routes are data, not code - modify at runtime
Cost efficiency: KEDA autoscaling from zero to max, pay only for active processing

Core idea: Write pure Python functions. Asya handles queues, routing, scaling, and monitoring.

📘 Documentation • 🚀 Quick Start • 🏗️ Architecture • 💡 Concepts

Battle-tested at Delivery Hero for global-scale AI-powered image enhancement. Now powering LLM and agentic workflows.

When to Use Asya🎭

✅ Ideal For

Multi-step AI/ML pipelines:

Document processing (OCR → classification → extraction → storage)
Image pipelines (resize → detect → classify → tag)
LLM workflows (retrieval → prompt → generate → judge → refine)
Video analysis (split → transcribe → summarize → translate)

Event-driven workloads:

Webhook processing (GitHub, Stripe, Twilio events)
Batch predictions (scheduled model inference)
Async API backends (user uploads → background processing)

Cost-sensitive deployments:

GPU inference (scale to zero between batches, avoid idle costs)
Bursty traffic (10x scale-up for peak hours, zero off-peak)
Dev/staging environments (minimize resource waste)

❌ Not Ideal For

Real-time inference < 100ms latency: Queue overhead adds latency (use KServe/Seldon instead)
Training jobs: Use Kubeflow, Ray Train, or native Kubernetes Jobs instead

See: Motivation | Core Concepts | Use Cases

For Data Scientists 🧑‍🔬

Write pure Python functions - no decorators, no DAGs, no infrastructure code:

# handler.py
def process(payload: dict) -> dict:
    return {
        **payload,  # Keep existing data
        "result": my_model.predict(payload["input"])
    }

Class handlers for stateful initialization (model loading):

class MyActor:
    def __init__(self, model_path: str = "/models/default"):
        self.model = load_model(model_path)  # Loaded once at pod startup

    def process(self, payload: dict) -> dict:
        return {
            **payload,
            "prediction": self.model.predict(payload["text"])
        }

Envelope mode for dynamic routing (agents, LLM judges):

class LLMJudge:
    def __init__(self, threshold: float = 0.8):
        self.model = load_llm("/models/judge")
        self.threshold = float(threshold)

    def process(self, envelope: dict) -> dict:
        payload = envelope["payload"]
        score = self.model.judge(payload["llm_response"])
        payload["judge_score"] = score

        # Dynamically modify route based on LLM judge score
        route = envelope["route"]
        if score < self.threshold:
            route["actors"].insert(route["current"] + 1, "llm-refiner")

        route["current"] += 1
        return envelope

Pattern: Enrich payload with your results, pass it to next actor. Full pipeline history preserved.

See: Quickstart for Data Scientists | Handler Examples

For Platform Engineers ⚙️

Deploy actors via Kubernetes CRDs:

apiVersion: asya.sh/v1alpha1
kind: AsyncActor
metadata:
  name: text-classifier
spec:
  transport: sqs  # or rabbitmq
  scaling:
    enabled: true
    minReplicas: 0
    maxReplicas: 100
    queueLength: 5  # Target: 5 messages per pod
  workload:
    kind: Deployment
    template:
      spec:
        containers:
        - name: asya-runtime
          image: my-classifier:latest
          env:
          - name: ASYA_HANDLER
            value: "classifier.TextClassifier.process"
          resources:
            limits:
              nvidia.com/gpu: 1

What happens:

Operator creates queue asya-text-classifier
Operator injects sidecar for message routing
KEDA monitors queue depth, scales 0→100 pods
Sidecar routes messages: Queue → Unix socket → Your code → Next queue

Transports: SQS (AWS), RabbitMQ (self-hosted), Kafka/NATS (planned)

See: Quickstart for Platform Engineers | Installation Guides | AsyncActor Examples

Architecture

Asya uses a sidecar pattern for message routing:

Operator watches AsyncActor CRDs, injects sidecars, configures KEDA
Sidecar handles queue consumption, routing, retries (Go)
Runtime executes your Python handler via Unix socket
Gateway (optional) provides MCP HTTP API for envelope submission and SSE streaming
KEDA monitors queue depth, scales actors 0→N

Message flow: Queue → Sidecar → Your Code → Sidecar → Next Queue

See: Architecture Documentation for system diagram, component details, protocols, and deployment patterns

Quick Start

Contributing

We welcome contributions! See CONTRIBUTING.md for:

Development setup (Go, Python, Docker, Make)
Testing workflow (unit, component, integration, E2E)
Code standards and linting
Pull request process

Prerequisites: Go 1.23+, Python 3.13+, Docker, Make, uv

Quick commands:

make build              # Build all components
make test-unit          # Unit tests (Go + Python)
make test-integration   # Integration tests (Docker Compose)
make test-e2e           # E2E tests (Kind cluster)
make lint               # Linters with auto-fix

License

Licensed under the Apache License, Version 2.0. See LICENSE for details.

Project Status

Alpha software under active development. APIs may change. Production use requires thorough testing.

Maintainers:

Artem Yushkovskiy 🐕 (@atemate, @atemate-dh)

Roadmap (see GitHub Discussions):

Stabilization and API refinement
Additional transports (Kafka, NATS, Google Pub/Sub)
Fast pod startup (PVC for model storage)
Integrations: KAITO, Knative
Enhanced observability (OpenTelemetry tracing)
Multi-cluster routing

Feedback: Open an issue or discussion on GitHub ❤️

Asya: Фреймворк для AI/ML-ворклоув на Kubernetes

Asya (от Async Actors) — это основанный на очередях фреймворк для оркестрации AI/ML-нагрузок на Kubernetes. Ключевая идея: вы пишете чистые Python-функции, а Asya берёт на себя очереди, маршрутизацию, масштабирование и мониторинг.

Протестирован в Delivery Hero для AI-обработки изображений на глобальном масштабе, сейчас используется для LLM- и агентных ворклоувов.

📘 Документация • 🚀 Быстрый старт • 🏗️ Архитектура • 💡 Концепции

Когда стоит использовать Asya

✅ Подходит для

Многошаговые AI/ML-пайплайны: обработка документов (OCR → классификация → извлечение → сохранение), пайплайны изображений (изменение размера → детекция → классификация → тегирование), LLM-ворклоувы (поиск → промпт → генерация → оценка → уточнение), видеоаналитика (разбивка → транскрибация → суммаризация → перевод)
Event-driven нагрузки: обработка вебхуков (GitHub, Stripe, Twilio), пакетные предсказания, асинхронные API-бэкенды (загрузка пользователем → фоновая обработка)
Cost-sensitive развёртывания: GPU-инференс (масштабирование до нуля между батчами), пиковый трафик (увеличение в 10x в часы пик, ноль в остальное время), dev/staging-среды (минимизация потребления ресурсов)

❌ Не подходит для

Real-time инференс с латентностью < 100 мс: накладные расходы очереди добавляют задержку (используйте KServe/Seldon)
Задачи обучения: используйте Kubeflow, Ray Train или нативные Kubernetes Jobs

Подробнее: Мотивация | Основные концепции | Примеры использования

Для Data Scientists

Пишите чистые Python-функции — без декораторов, DAG и инфраструктурного кода:

# handler.py
def process(payload: dict) -> dict:
    return {
        **payload,  # Сохраняем существующие данные
        "result": my_model.predict(payload["input"])
    }

Классовые обработчики для инициализации с состоянием (загрузка модели):

class MyActor:
    def __init__(self, model_path: str = "/models/default"):
        self.model = load_model(model_path)  # Загружается один раз при старте пода

    def process(self, payload: dict) -> dict:
        return {
            **payload,
            "prediction": self.model.predict(payload["text"])
        }

Режим envelope для динамической маршрутизации (агенты, LLM-судьи):

class LLMJudge:
    def __init__(self, threshold: float = 0.8):
        self.model = load_llm("/models/judge")
        self.threshold = float(threshold)

    def process(self, envelope: dict) -> dict:
        payload = envelope["payload"]
        score = self.model.judge(payload["llm_response"])
        payload["judge_score"] = score

        route = envelope["route"]
        if score < self.threshold:
            route["actors"].insert(route["current"] + 1, "llm-refiner")

        route["current"] += 1
        return envelope

Паттерн: обогащаете payload результатами и передаёте следующему актору. Полная история пайплайна сохраняется.

Подробнее: Быстрый старт для Data Scientists | Примеры обработчиков

Для Platform Engineer'ов

Развёртывание акторов через Kubernetes CRD:

apiVersion: asya.sh/v1alpha1
kind: AsyncActor
metadata:
  name: text-classifier
spec:
  transport: sqs  # или rabbitmq
  scaling:
    enabled: true
    minReplicas: 0
    maxReplicas: 100
    queueLength: 5  # Цель: 5 сообщений на под
  workload:
    kind: Deployment
    template:
      spec:
        containers:
        - name: asya-runtime
          image: my-classifier:latest
          env:
          - name: ASYA_HANDLER
            value: "classifier.TextClassifier.process"
          resources:
            limits:
              nvidia.com/gpu: 1

Что происходит:

Оператор создаёт очередь asya-text-classifier
Оператор внедряет sidecar для маршрутизации сообщений
KEDA мониторит глубину очереди, масштабирует 0→100 подов
Sidecar маршрутизирует сообщения: Queue → Unix socket → Ваш код → Next queue

Транспорты: SQS (AWS), RabbitMQ (self-hosted), Kafka/NATS (планируются)

Подробнее: Быстрый старт для Platform Engineer'ов | Инструкции по установке | Примеры AsyncActor

Архитектура

Asya использует паттерн sidecar для маршрутизации сообщений:

Оператор следит за AsyncActor CRD, внедряет sidecar'ы, настраивает KEDA
Sidecar обрабатывает потребление из очереди, маршрутизацию, повторные попытки (на Go)
Runtime выполняет ваш Python-обработчик через Unix socket
Gateway (опционально) предоставляет MCP HTTP API для отправки сообщений и SSE-стриминга
KEDA мониторит глубину очереди, масштабирует акторы 0→N

Поток сообщений: Queue → Sidecar → Ваш код → Sidecar → Next Queue

Подробнее: Документация по архитектуре — диаграмма системы, детали компонентов, протоколы и паттерны развёртывания.

Быстрый старт

Разработка

Мы приветствуем вклад! См. CONTRIBUTING.md по:

Настройке окружения (Go, Python, Docker, Make)
Тестированию (unit, component, integration, E2E)
Стандартам кода и линтингу
Процессу Pull Request

Требования: Go 1.23+, Python 3.13+, Docker, Make, uv

Основные команды:

make build             # Сборка всех компонентов
make test-unit         # Unit-тесты (Go + Python)
make test-integration  # Интеграционные тесты (Docker Compose)
make test-e2e          # E2E-тесты (Kind cluster)
make lint              # Линтеры с автоисправлением

Лицензия

Статус проекта

Alpha — активная разработка, API могут меняться. Для production-использования требуется тщательное тестирование.

Мейнтейнеры: Artem Yushkovskiy ( @atemate, @atemate-dh )

Планы (см. GitHub Discussions):

Стабилизация и уточнение API
Дополнительные транспорты (Kafka, NATS, Google Pub/Sub)
Быстрый старт подов (PVC для моделей)
Интеграции: KAITO, Knative
Улучшенная наблюдаемость (OpenTelemetry tracing)
Маршрутизация между кластерами

Обратная связь: Открывайте issue или обсуждение на GitHub ❤️

Источник: https://mcpmarket.com/server/asya