Evento Framework
  • Introduction
  • Architecture Overview
    • Distributed Systems & Microservices
    • Recative Manifesto & Reactive Principles
    • State-of-the-art Patterns
      • DDD (Domain Driven Design)
      • CQRS (Command Query Responsability Separation)
      • Event Sourcing
      • Messaging
      • Saga
  • GETTING STARTED
    • Quick Start
    • TodoList - RECQ Tutorial
      • Problem Description and Requirement Gathering
      • RECQ Payload Design
      • RECQ Components Design
      • Set up your Development Environment
      • RECQ Payload Evento Implementation
        • Domain Commands
        • Domain Events
        • Views
        • Queries
      • RECQ Components Evento Implementation with Spring Data
        • TodoListAggregate
        • TodoList Model with Spring Data
        • TodoListProjector
        • TodoListProjection
        • TodoList Invoker
      • Expose the RECQ architecture with Spring Web
      • Test Your App
    • Extend TodoList - Handle Complexity Tutorial
      • Unique identifier generation
      • Extends behaviors with Observer and Services
      • Cross Domain Consistency with Sagas
      • Handle Real time data updates with MQTT and Save-Notify Pattern
  • RECQ Patterns
    • RECQ Patterns
    • RECQ System Pattern
      • Component
      • Message Gateway
      • System State Store
    • RECQ Communication Pattern
      • Component to Component
      • Component to System State Store
      • System State Store to Component
    • RECQ Component Pattern
      • Aggregate
      • Projector
      • Projection
      • Service
      • Invoker
      • Saga
      • Observer
  • Evento Framework
    • Evento Framework Introcution
    • Payload and Messages
      • Command
        • Domain Command
        • Service Command
      • Event
        • Domain and Service Event
      • Query and View
    • @Component
      • @Aggregate
        • Aggregate State
        • @AggregateCommandHandler
        • @EventSourcingHandler
      • @Projector
        • Projector @EventHandler
      • @Projection
        • @QueryHandler
      • @Service
        • @CommandHandler
      • @Invoker
      • @Saga
        • SagaState
        • @SagaEventHandler
      • @Observer
    • Dead Event Queues
    • EventoBundle
      • EventoServerMessageBusConfiguration
      • ConsumerStateStore
        • InMemoryConsumerStateStore
        • PostgresConsumerStateStore
        • MysqlConsumerStateStore
      • Context
      • TracingAgend and @Track
        • SentryTracingAgent
      • Autoscaling Protocol
        • ThreadCountAutoscalingProtocol
      • Injector and @Component
  • Evento Server
    • Evento Server Introduction
    • SetUp Evento Server
      • Advanced Options
      • Evento Event Store Modes: APES and CPES
    • Evento Server Cluster
    • Bundle Deploy Script
  • EVENTO GUI
    • Explore RECQ Systems Visually
    • GUI Auth
    • Payload Catalog
    • Component Catalog
    • Bundle Catalog
    • Cluster Status (Experimental)
    • Flows
      • Performance Evaluation
    • Application Graph
    • System State Store
  • Evento CLI
    • Evento CLI Introduction
    • Update Version
    • Publish
Powered by GitBook
On this page
  1. Evento Server

Evento Server Introduction

The Maestro of Distributed Systems

In the intricate world of distributed applications, seamless communication and coordinated action are essential for success. Evento Server emerges as a maestro, orchestrating message flow, event processing, and resource management within a cluster of applications. This chapter introduces the key responsibilities of Evento Server, highlighting its role in building robust and scalable distributed systems.

Message Gateway: The Heart of Communication

Evento Server acts as a central message gateway, facilitating the exchange of messages (payloads) between various components within a distributed system. Applications can:

  • Publish Messages: Send messages containing data or representing events to specific topics. These topics act as designated channels for message routing.

  • Subscribe to Topics: Register interest in specific topics, enabling them to receive messages published on those channels.

This publish-subscribe pattern decouples applications, promoting loose coupling. Applications don't need to be aware of each other's location or implementation details, simplifying development and deployment.

Bundle Registration: The Foundation for Execution

Evento Server acts as the central registry for deployable units within your distributed system. These units are known as bundles. A bundle is essentially a JAR archive containing the executable code (typically written in Java) and a descriptor file. This descriptor file provides crucial information about the bundle, including:

  • Description: Json explanation of the bundle's purpose and functionality.

  • RECQ Components and Invocations: Details about the specific RECQcomponents encapsulated within the bundle. This section of the descriptor file outlines the available components and how they can be invoked.

By registering bundles with Evento Server, you essentially make them available for deployment and execution within the cluster. Evento Server utilizes the information gleaned from the bundle descriptor during deployment to configure and manage the bundle instances.

Beyond Messaging: Event Store and the Power of History

Evento Server goes beyond basic message routing by offering an Event Store. This functionality is particularly valuable in the context of the REQQ architecture. The Event Store acts as a central repository for a chronologically ordered sequence of events captured by running bundles. This enables applications to:

  • Record Events: Capture significant changes in the system state as events.

  • Replay Events: Re-execute a sequence of events to recreate a specific system state or for debugging purposes.

This ability to record and replay events empowers developers to build robust and auditable applications.

Cluster Management: Keeping Track of the Ensemble

Evento Server acts as the central registry for all running application bundles within the cluster. It maintains critical information about each bundle, including its:

  • Status: Monitors the health and operational state of each bundle instance.

  • Configuration: Stores bundle-specific configuration details.

  • Location: Tracks where each bundle instance is currently running within the cluster.

This centralized management simplifies monitoring and troubleshooting within the distributed system.

Telemetry Server: Understanding Application Behavior

Evento Server serves as a Telemetry Server, collecting and storing telemetry data generated by applications using the Evento framework. This data might include metrics like:

  • Message processing times

  • Resource utilization

  • Error rates

By analyzing this data, developers gain valuable insights into application behavior, enabling them to identify bottlenecks, optimize performance, and make informed decisions for continuous improvement.

Cluster Balancing: Scaling with Demand

Evento Server plays a crucial role in cluster balancing. It receives signals from autoscaling protocols implemented within bundles. These signals indicate when to:

  • Scale Up: Spawn new bundle instances to handle increased workload demands.

  • Scale Down: Terminate idle bundle instances to conserve resources.

By dynamically adjusting the number of running bundles based on real-time needs, Evento Server ensures optimal resource utilization and efficient application performance.

In Conclusion

Evento Server acts as the central nervous system of a distributed system built with the Evento framework. It facilitates communication between applications, provides a mechanism for recording and replaying events, manages the cluster of running bundles (registered with their descriptions), gathers telemetry data, and enables dynamic scaling. By leveraging these functionalities, developers can build robust, scalable, and maintainable distributed applications. As you delve deeper into the Evento framework, you'll discover how each component interacts with Evento Server to create a coordinated and responsive application ecosystem.

PreviousInjector and @ComponentNextSetUp Evento Server

Last updated 12 months ago