Evaluation Guide

Runtime architecture

Genus Services is the server-side component of the Genus platform, executing your no-code applications in a cloud-native microservices architecture. This article covers its architecture and the critical aspects of runtime execution.

  • Genus Services reads and interprets application models (app models) stored in a database. Based on this interpretation, Genus Services delivers application services to users through Genus Web, Genus Studio, Genus Desktop, and API interfaces.

    Genus interprets and executes the app model directly. This pure model-driven approach means no code generation or compilation is involved in the deployment or execution of models, with these advantages:

    • Sustainability: The Genus platform can evolve and modernize without impacting the app model. And vice versa.

    • Security: The model’s configured security is preserved, preventing potential vulnerabilities.

    • Simplicity: No custom code extensions are possible, ensuring consistent and maintainable development.

    External custom code can be integrated through REST or SOAP services, ensuring seamless integration without compromising the integrity of your Genus application model.

  • Genus Services runtime uses stateless microservices to interpret and execute applications, ensuring high cohesion and low coupling. Each microservice has a specific responsibility with a clearly defined interface. Key features include:

    • Programming Language Diversity: Microservices are developed using the programming language best suited to their tasks, such as TypeScript (Node.js), .NET, and Delphi (Pascal).

    • Scalability and Flexibility: Microservices are stateless, dynamically scalable, and capable of running as multi-container and multi-threaded processes.

    • Security: Client requests include all necessary information and are validated server-side, ensuring consistent security measures.

    Genus Services relies entirely on Kubernetes to orchestrate its microservices, which are deployed as Linux containers running in Kubernetes pods. This enables deployment across major cloud providers like Microsoft Azure, Amazon Web Services, and Google Cloud, as well as on-premises environments. Additionally, Genus Services supports deployment on OVHCloud as a cloud provider and is compatible with OpenShift for on-premises solutions.

  • Authentication between microservices in a Genus Kubernetes cluster uses JWT (JSON Web Tokens). This ensures that calls between microservices can be performed "on behalf of" users, maintaining secure and authenticated communication within the cluster. Additionally, Genus Services supports HTTPS for secure external communication.

  • Kubernetes enables Genus Services to dynamically allocate resources based on workload. This ensures that applications remain scalable, and adaptable to changing demands, whether deployed in the cloud or on-premises.

    This robust runtime architecture guarantees reliable and high-performance execution of your no-code applications.

Runtime architecture components

  • Responsible for scheduling and executing modeled agent jobs, which are comparable to batch jobs, running server-side.

  • Authenticates users via Identity Providers

  • Responsible for authorizing access to different parts of the application through permissions on a metadata level.

  • Responsible for handling requests from standard CardDAV clients, such as Microsoft’s, Apple’s, and Google’s contact apps. Contact lists or address books can be defined in Genus Studio and can expose any contact-related data to third-party applications.

  • Responsible for executing CRUD (Create, Read, Update, Delete) commands on the customer data based on the metadata. This is an essential service to enable codeless, metadata-interpreting applications.

    The service verifies the CRUD commands against the metadata before executing them, to ensure that they follow configured rules for data integrity, permissions, and other security aspects.

  • Responsible for aggregating data and maintaining data marts, enabling advanced dashboard- and analytics functionality. The microservice handles requests and contains logic for running queries towards the data marts.

  • Helps optimize the communication with underlying databases, building on statistics and Data Definition Language (DDL) requests. The service also provides support for reverse engineering of databases by reading database information (tables, columns, indexes, etc.)

  • Provides file- and file format services, including email format services and both client- and server-side document merge. This microservice is partly built on top of the third-party library Aspose.

  • The Gateway Service routes all incoming requests to other microservices within the runtime environment.

  • Delivers sections or articles to our desktop- and web clients from the markdown-based help documentation of our platform.

  • The ingress is used to control the routing of incoming traffic. A controller interprets the ingress rules and routes traffic to the correct microservices, while the load balancer routes the external traffic into the Kubernetes cluster.

  • Delivers natural language translations and word lists in an i18n format. Enables the Genus applications to be accessible in several languages.

  • Responsible for commands towards Kubernetes to control the pods in a namespace, fetch a microservices version, assign trace level, and route to green/blue namespace, etc.

  • Collects live update messages from other Genus microservices.

  • Reads messages in queues (stored in Redis) and sends live updates and trace messages to Genus Web and Genus Desktop clients via web sockets.

  • Used by Genus Studio to read and write application models (metadata) to and from the Metadata Repository. This service is not used by Genus Desktop, Genus Web, or APIs.

  • Responsible for reading metadata from the Metadata Repository to provide application model information to Genus Web, Genus Desktop and APIs.

  • Enables the consumption of REST services exposed by third parties from your Genus application.

  • Exposes REST services and handles calls from third parties. REST endpoints are subject to the same security model as all other communication with your Genus applications.

  • Responsible for asynchronous mail delivery from your Genus application.

  • Enables the consumption of SOAP services exposed by third parties from your Genus application.

  • Exposes SOAP services and handles calls from third parties. SOAP endpoints are subject to the same security model as all other communication with your applications.

  • Responsible for interfacing with the supported database engines, such as Microsoft SQL Server, Oracle, and DB2. This includes database driver handling, threading, etc.

  • Provides functionality for streaming of data, including videos, to/from databases or BLOB-storage providers.

  • Responsible for monitoring and collecting trace messages from other Genus microservices and making these available to clients through Redis and the Message Subscription Service.

  • Handles requests from any Webcal client, such as calendar apps from Microsoft or Apple. Calendars are defined in Genus Studio and you can expose any calendar-related data in your application.

  • Supports Microsoft Office Online clients reading and editing documents stored in your Genus application. WOPI is short for Web Application Open Platform Interface Protocol.