LogoLogo
Home
Core Platform
Core Platform
  • Introduction
    • Overview
    • Use Cases
    • Architecture
    • Built with ML & AI
    • Quick Start
  • Examples
    • Training Examples
      • API Flow Examples
      • Microservice Examples
      • UI Example
      • Exercise: Hello World API
      • Exercise: Test State
      • Exercise: Test UI
    • Exercise: To-do List
      • To-do List Runner
      • To-do List Gateway
      • To-do List UI
      • To-do List Query
  • Troubleshooting
    • Rierino Packages
    • Release Notes
    • Useful Checks
    • Error Codes
  • Devops
    • Overview
    • API Flows
      • Using the Saga Screen
      • Defining a Saga
      • Configuring Saga Steps
        • Event Step
        • Transform Step
          • Transform Classes
        • Condition Step
          • Condition Classes
        • Step Link
      • Injecting Variables
    • Microservices
      • Runners
        • Using the Runner Screen
        • Defining a Runner
        • Managing Runner Settings
        • Adding Runner Elements
        • Deploying Runners
          • Spring Runners
          • Samza Runners
          • Camel Runners
      • Elements
        • Systems
        • State Managers
          • Typical Use Cases
          • State Data Structure
          • Local States
            • In-Memory Map
            • Caffeine Cache
            • Samza Based
            • Lucene Based
            • Single File
            • Multiple Files
            • Selected IDs Map
            • Indexed Map
          • Shared States
            • MongoDB Collection
            • Jooq (SQL) Table
            • Redis Map
            • Couchbase Collection
            • Elasticsearch Index
            • Elasticsearch Joined
            • Etcd Namespace
          • Specialized States
            • CRUD Service
            • Odata Service
          • State Coordinators
            • Lazy Cache Coordinator
            • Event Store Coordinator
            • Write thru Coordinator
          • Loading Strategies
          • ID Generators
        • Listeners
        • Query Managers
          • MongoDB
          • Elasticsearch
          • Lucene
          • SQL Based
          • Odata Service
        • Handlers
          • Core Handlers
            • Write Data
            • Read Data
            • Query Data
            • Apply Rules
            • Call Rest API
            • Generate Text/Html
            • Parse Html
            • Generate Secrets
            • Orchestrate User Task
            • Perform File Operation
            • Run Shell Command
            • Send/Receive Emails
          • Custom Code Handlers
            • Run Scripts
            • Run Java Code
            • Run Java Package
          • Flow Handlers
            • Orchestrate Saga
            • Loop Each Entry
            • Run Multiple Steps
            • Buffer Payloads
            • Merge Parallel Steps
            • Log Event
            • Send Event
            • Validate Event
            • Transform Event
            • Perform DB Transaction
            • Trigger Runner Command
            • Do Nothing
            • Modify Role Data
            • Enrich Role Data
            • Convert Pulse to Journal
          • Gateway Handlers
            • Authenticate
              • No Authentication
              • State Based
              • Keycloak Based
            • Sessionize
          • Specialized Handlers
            • Apply Advanced Rules
            • Calculate Real-time Metrics
            • Score ML Models
            • Score LangChain Models
            • Service MCP Requests
            • Service A2A Requests
            • Consume Web of Things
            • Perform Text Embedding
            • Run Python Procedure
            • Generate Excel
            • Generate PDF
            • Call SOAP API
            • Integrate with Camel
        • Actions
        • Streams
          • Kafka Topic
          • CDC Feed
          • Camel Component
        • Roles
        • Generic Settings
        • Global Settings
      • Deployments
        • Defining a Deployment
        • Alternative Loaders
    • Gateway & Security
      • Gateway Servers
        • Gateway Systems
        • Gateway Channels
        • Gateway Services
        • Gateway Tokens
      • APIs
        • OpenAPI Specification
        • Response Formats
    • Administration
      • Managing Deployments
      • Sending Commands
      • Streaming Messages
      • Migrating Assets
    • Batch Tasks
      • Python Processes
      • Python Iterators
      • Python Processors
    • Pro-Code
      • Custom Handlers
      • Custom State Managers
      • Custom Query Managers
      • Custom CDC Managers
  • Design
    • Overview
    • User Interface
      • Apps
      • UIs
        • Listers
        • Widgets
          • Value Widgets
          • Array Widgets
          • Object Widgets
          • Indirect Widgets
          • Atom Widgets
        • Menus
          • Lister Menu Actions
          • Selection Menu Actions
          • Editor Menu Actions
          • Widget Menu Actions
          • Custom Menu Actions
          • RAI Menu Actions
        • Extended Scope
          • Conditional Display
          • Data Context
          • Extra Data
          • Default Item
          • Extra Events
      • Options
      • Translations
      • Icons
      • Styles
      • Components
    • API Mapping
    • Data Schema
      • Common Data
  • Configuration
    • Overview
    • Queries
      • Query Types
      • Query Platforms
        • MongoDB Queries
        • Odata Queries
        • SQL Queries
        • Elasticsearch Queries
        • Lucene Queries
        • Siddhi Queries
    • Business Rules
      • Drools Rules
    • Dynamic Handlers
  • Data Science
    • Overview
    • ML Models
      • Scheduler Platforms
        • Airflow Scheduler
    • GenAI Models
    • MCP Servers
    • Complex Event Processing
      • Siddhi Data Flows
    • Data Visualizations
    • Customizations
  • EXTENSIONS
    • JMESPath
    • Handlebars
Powered by GitBook

© Rierino Software Inc. 2025. All rights reserved.

On this page
  • Hyper-Flexible Front-end
  • External UIs & Systems
  • Admin UI
  • Hyper-Scalable Back-end
  • API Gateways
  • Micro-Composable Services
  • Batch Tasks
  • 3rd Party Platforms
  • Plug & Play Storage
  • Data Stores
  • File Systems
  1. Introduction

Architecture

Rierino platform covers various components, used in front-end, microservices, data storage and integration as well as analytics

PreviousUse CasesNextBuilt with ML & AI

Last updated 7 months ago

Key components included in a full deployment are as follows:

Hyper-Flexible Front-end

External UIs & Systems

As a headless platform, Rierino allows integration with any customer facing channel (e.g. web, app, social, video, virtual) and technology through its set of APIs. Removing dependency between the platform and the front-end gives creative freedom for branded and customized user experiences, while allowing microservice developers to focus on performance and cost optimization.

Admin UI

Rierino is shipped with a highly customizable Next.js front-end for the internal users, referred to as the Admin UI. While, similar to the customer facing channels, it is possible to integrate Rierino back-end with any UI for administration through its set of admin APIs, Rierino already provides a flexible Admin UI for easier and faster deployment.

Hyper-Scalable Back-end

API Gateways

Rierino deployments include a gateway layer, which includes request routing, authentication and session management capabilities. While it is possible to use an external API gateway such as Kong, Rierino already provides a flexible layer for easier and faster deployment.

This layer consists of a dedicated Spring Webflux deployment for Gateway Server which communicates with runner(s) responsible for authentication and session management activities.

All authentication and session management actions are managed as API flows, making them 100% customizable, allowing integration of existing security systems and policies.

While it is possible to deploy a single gateway layer for all types of users and requests, it is recommended to have dedicated instances for different user types (e.g. internal users, sellers, buyers) to allow customized network security and performance management configurations for each.

Micro-Composable Services

While it is possible to develop and deploy service runners using any language or platform, Rierino is shipped with 3 main types of Java based runners:

  • Spring Runners: Using Spring Webflux framework to deploy reactive web runners

  • Samza Runners: Using Apache Samza library to deploy message based runners

  • Camel Runners: Using Apache Camel library to deploy runners capable of custom integrations

Batch Tasks

Rierino is shipped with a set of Python libraries for most common analytics & batch tasks, such as data integration, customer segmentation, recommendation models, data quality assessment, data import or export.

These batch tasks are typically deployed and triggered by a scheduler (e.g. Airflow), ensuring traceability and resilience of each task.

In addition to these tasks, Rierino is shipped with a set of devops features, to simplify deployment and maintenance of runners, which can be also managed through external CI/CD platforms.

3rd Party Platforms

Rierino provides ability to integrate with 3rd party solutions (such as payments, OMS, WMS) through both REST API and data based integration approaches.

Plug & Play Storage

Data Stores

Rierino supports use of various data systems with varying latency and proximity. Each of these systems are replaceable with minimal effort (such as developing an adapter if necessary).

  • Cache: Local and shared caching options for lowest latency operations

  • Operational: NoSQL & SQL data stores used as master or read/write stores

  • Search: Specialized search engines for use cases such as product search

  • Real-Time: Columnar or similar real-time analytics data stores for insights

  • Data Lake: Big data store for high latency and analytics use cases

File Systems

In addition to structured/semi-structured data systems, Rierino supports use of file systems such as FTP, HDFS, S3 for storing assets such as trained ML models, digital assets and documents.

The Admin UI can be customized by configuring Apps, UIs, Sources and Options as defined in section. It also has an embedded component, which can service BI dashboards, ML models and data quality insights directly within the interface where users manage products, prices, etc.

The gateway layer can be customized by configuring Systems, Channels, Services and Tokens as defined in section.

Micro-composable service runners sit at the heart of Rierino platform, and can be designed, deployed and controlled through the admin UI. Each service runner consists of a specific set of which define the data sources it can access, list of functions it can execute and message channels it can use, providing ability to build specialized micro-services.

user interface
data visualization
Gateway & Security
elements
Platform Architecture