Introduction of nyssr.net

Nodes

A nyssr.net node is a Java micro-kernel that can load hundreds of plugins at startup. Nodes are small (1.4 MBytes), start quickly (200ms) and can be executed in any number on a computer or in containers.

Services

Plugins contain local services (based on interfaces), microservices (services for the network) and nanoservices (services that only process one message type).

The node network

Nodes are networked with each other in a mesh, i.e. each node is connected to several other nodes via TCP channels. Services communicate with each other exclusively by means of messages, network-wide.

High-performance communication

The asynchronous messaging between nodes is optimized for speed and data efficiency. Therefore, nodes can operate off the main data highways.

Microservice resolution

Services are found automatically. Each microservice has a unique ID. A message to a microservice that has this ID in the header is automatically delivered to the service, regardless of which node the service is running on.

Load balancing

The same microservice can be used simultaneously on different nodes. The system automatically distributes the load across the instances. The same applies to applications and UI dialogs.

Like one big system

nyssr.net is designed to manage a large number of small services. Thanks to the automatic service resolution and lightning-fast communication, you will not experience any performance disadvantages, neither during development nor during operation.

No configuration

You can only control and use thousands of microservices if no configuration is necessary. The microservices only need to be present in the network.

No code sharing

Generally, no source code is shared between service providers and service consumers. This avoids dependencies on shared interfaces and eliminates the need to upgrade all services simultaneously to a new level.

100% Asynchronous Design

Everything in nyssr.net is designed with an asynchronous architecture: nodes, messages, applications, and UI. As a developer, you only respond to events. Only the internal services within nodes remain partially interface-based.

Peer-to-peer

The nyssr.net network monitors itself. All links are continuously monitored. If a node fails or new nodes are added, all other nodes are automatically notified. Broadcasts are used to automatically distribute important events.

Maximum scaling

A node network can scale as required. Additional nodes can be added during operation. We do not scale monoliths, but asynchronous services.

Maximum resilience

You can operate everything redundantly: Nodes, services, UI components. If a link fails, the messages use a different route. If a node fails, the other nodes and service instances survive.

Work scaling

Host UI dialogs where the team works. The team can monitor the nodes and intervene if necessary. It can independently distribute new versions and drive further development.