openframe-oss-tenant README

The project's README from github.com/flamingo-stack/openframe-oss-tenant. As one markdown file: README.md.

OpenFrame

License

OpenFrame OSS Tenant

OpenFrame OSS Tenant is the multi-service, multi-tenant open-source foundation of the OpenFrame platform — an AI-powered MSP (Managed Service Provider) platform built by Flamingo that replaces expensive proprietary software with intelligent automation.

It integrates device management, real-time messaging, AI-assisted support (Mingo AI for technicians, Fae for clients), and event-driven automation across a polyglot microservice architecture built on Spring Boot (Java) and Rust.

OpenFrame v0.7.8: Fleet MDM Integration & Platform Architecture Deep Dive

✨ Features

🏗️ Architecture

All client traffic passes through the Spring Cloud Gateway. Backend services communicate via HTTP/GraphQL internally and asynchronously via Kafka and NATS JetStream. The Rust agent communicates exclusively over NATS.

graph TB
    subgraph Clients["Client Layer"]
        FrontendUI["openframe-frontend\n(Web UI)"]
    end

    subgraph Gateway["Edge Layer"]
        GW["Gateway Service :8081\n(Spring Cloud Gateway)"]
    end

    subgraph CoreServices["Core Services"]
        API["API Service :8080\n(Spring Boot + GraphQL)"]
        AuthServer["Auth Server :8082\n(OAuth2 / OIDC)"]
        ExtAPI["External API :8083\n(Spring Boot REST)"]
        StreamSvc["Stream Service :8085\n(Kafka Streams)"]
        ClientSvc["Client Service :8084\n(Spring Boot + NATS)"]
    end

    subgraph AgentLayer["Agent Layer"]
        OFClient["openframe-client\n(Rust System Agent)"]
    end

    subgraph DataLayer["Data Layer"]
        Mongo[("MongoDB")]
        Cassandra[("Cassandra")]
        Pinot[("Apache Pinot")]
        Redis[("Redis")]
        Kafka[("Apache Kafka")]
        NATS[("NATS JetStream")]
    end

    FrontendUI --> GW
    GW --> API
    GW --> AuthServer
    GW --> ExtAPI
    API --> Mongo
    API --> Pinot
    API --> Kafka
    StreamSvc --> Kafka
    StreamSvc --> Cassandra
    StreamSvc --> Pinot
    ClientSvc --> Mongo
    ClientSvc --> NATS
    AuthServer --> Mongo
    OFClient --> NATS
    OFClient --> API

Core Components

Component Language Port Responsibility
API Service Java / Spring Boot 3.3 8080 REST + GraphQL APIs; tickets, dialogs, AI settings, tenant management
Authorization Server Java / Spring Authorization Server 8082 Multi-tenant OAuth2/OIDC; RSA-signed JWT issuance; SSO (Google, Microsoft)
Gateway Java / Spring Cloud Gateway 8081 Security enforcement, JWT validation, routing, WebSocket proxy
External API Java / Spring Boot 8083 Rate-limited public API endpoints with API key management
Stream Service Java / Kafka Streams 8085 Real-time event normalization, enrichment, Cassandra/Pinot writes
Client Service Java / Spring Boot + NATS 8084 Agent lifecycle management, tool orchestration
openframe-client Rust — Cross-platform system agent; device registration, script execution, self-update

🚀 Quick Start

Prerequisites

Clone and Build

# 1. Clone the repository
git clone https://github.com/flamingo-stack/openframe-oss-tenant.git
cd openframe-oss-tenant

# 2. Build all backend services (Java / Spring Boot)
mvn clean install -DskipTests

# 3. Build the Rust agent
cd clients/openframe-client
OPENFRAME_VERSION=0.0.0-dev cargo build

# 4. Return to root
cd ../..

Run a Backend Service

# Start the API service
mvn spring-boot:run -pl openframe/services/openframe-api

Verify the Rust Agent

./clients/openframe-client/target/debug/openframe-client --help

Agent Doctor Check

cd clients/openframe-client
./target/debug/openframe-client doctor

Install Agent as a System Service

sudo ./target/release/openframe-client install \
  --serverUrl https://your-openframe-instance.example.com \
  --initialKey YOUR_INITIAL_KEY \
  --orgId YOUR_ORG_ID

🛠️ Technology Stack

Layer Technology
Backend services Java 21, Spring Boot 3.3, Spring Cloud Gateway, Spring Authorization Server, Netflix DGS (GraphQL)
Endpoint agent Rust (stable), async-nats, tokio, Velopack
Event streaming Apache Kafka, Kafka Streams
Agent messaging NATS JetStream
Primary datastore MongoDB (multi-tenant, tenant-scoped)
Time-series storage Apache Cassandra
Real-time analytics Apache Pinot
Cache / sessions Redis
Shared UI library @flamingo-stack/openframe-frontend-core (npm)

📁 Repository Structure

openframe-oss-tenant/
├── openframe/
│   └── services/              # Spring Boot microservices
│       ├── openframe-api/     # Core REST + GraphQL API (port 8080)
│       ├── openframe-gateway/ # Spring Cloud Gateway (port 8081)
│       ├── openframe-authorization-server/ # OAuth2/OIDC (port 8082)
│       ├── openframe-external-api/         # Public API (port 8083)
│       ├── openframe-client/  # Agent lifecycle service (port 8084)
│       ├── openframe-stream/  # Kafka Streams (port 8085)
│       ├── openframe-management/
│       └── openframe-config/
├── clients/
│   └── openframe-client/      # Rust cross-platform agent
├── manifests/                 # Kubernetes manifests & data service configs
└── pom.xml                    # Parent Maven POM

🔧 CLI Tools

The OpenFrame CLI tools are maintained in a separate repository:

📚 Documentation

Full documentation is available in the docs/ directory:

🤝 Community

All support, feature requests, bug reports, and development discussions happen in the OpenMSP Slack community — GitHub Issues and GitHub Discussions are not used.

Built with 💛 by the Flamingo team

openframe-oss-tenant (flamingo-stack/openframe-oss-tenant)

Searching Database…

1.1K ·GitHub
Openframe-oss-tenant
这是什么？OpenFrame OSS Tenant 是 OpenFrame 的开源多租户基础。OpenFrame 是一个 AI 驱动的 MSP（托管服务提供商）平台，用智能自动化、设备管理和 AI 辅助支持取代昂贵的专有 RMM/支持软件。
这是一个应用，还是一堆相互连接的服务？它是一个多语言微服务平台：多个 Spring Boot（Java）后端服务（API、Gateway、Auth Server、Stream、Client），外加一个独立的基于 Rust 的端点智能体，全部通过 Kafka、NATS 和共享数据存储连接在一起。
我怎么在本地把它跑起来？克隆仓库，用 Maven 构建 Java 服务、用 Cargo 构建 Rust 智能体，然后按照 Quick Start 部分逐个启动后端服务，并把 Rust 智能体验证/安装为系统服务。
构建之前我需要安装什么？在构建任何组件之前，你需要 JDK 21、Apache Maven 3.9+ 和 Rust 1.78+（通过 rustup 安装）。
自托管它是快速搞定的事，还是一项真正的工程？运行它需要同时照看七个后端服务，外加 MongoDB、Cassandra、Apache Pinot、Redis、Kafka 和 NATS JetStream——没有给出一条 Docker-compose 命令搞定的方案，只有逐个服务的 Maven/Rust 构建步骤，因此自托管需要实打实的基础设施投入。
这个平台是为谁打造的？它面向需要在受管客户端端点上执行远程管理、脚本编写（bash、PowerShell、Python、Nushell）和合规检查的 MSP 技术人员，以及他们所支持的客户。
端点智能体在 Windows、macOS 和 Linux 上的运行方式一样吗？一样。基于 Rust 的 openframe-client 在三者上都作为原生系统服务运行，负责脚本执行、工具管理，并通过 Velopack 自我更新。
不同客户（租户）之间的数据如何保持隔离？每个租户都有自己的 OAuth2 客户端、RSA 签名的 JWT，以及通过 TenantAwareMongoTemplate 实现的租户范围内 MongoDB 访问，因此数据不会跨租户边界泄露。
Mingo AI 是什么？Fae 又是什么？Mingo AI 是面向 MSP 技术人员的 AI 助手，Fae 则是面向终端客户的 AI 助手；两者都由流式 LLM 驱动，实时给出响应。
平台为什么同时使用 Kafka 和 NATS？Apache Kafka（配合 Kafka Streams）处理持久化的大容量事件处理，如设备事件和分析写入；NATS JetStream 则承载延迟更低的智能体消息传递和流式 AI 响应分块。
OpenFrame 的 CLI 工具在哪里？命令行工具不在这个仓库里——它们位于单独的项目 flamingo-stack/openframe-cli 中，有自己的安装指南和文档。
What are similar projects?SpringAll, JeecgBoot, SpringBoot-Labs, anythingmcp, emqx, spring-boot-demo, turnstone, Sa-Token
Which topics is it in?kafka, jwt, sso, oauth2, graphql, mongodb, microservices, redis, websocket, distributed-systems, shell, rest-api
Creator
flamingo-stack
Size
327.4 MB
Stars
1.1K
Updated
CommitOct 16Release1.1.5Aug 14
Age
1y
Commits · 90 Days