• Rating:
  • Views: 145
  • Author: JLupin
  • Comments: 0

What is JLupin Next Server ?

It is completely new server technology for Java applications configured by Spring Framework, where microservice architecture is implemented as many separated and closely cooperating JVMs.

It includes new implementations of self-healing, software load balancers, queues, zero downtime deployment and service discovery mechanisms to ensure reliability, performance and provide new management capabilities.

It is not another framework either set of loosely integrated open source technologies, it is a consistent suite to design, run and manage microservices.

Why do we need technology support for microservices ?

Because microservices described as “small autonomous services that works together, modeled around a business domains” mean in practice “many cooperating processes” and that has very serious consequences for reliability and manageability for the whole system in microservices architecture. Microservices need specialized environment, featured with sophisticated functionalities to handle this challenge.

One of them is JLupin Next Server – application platform to run microservices, which seamlessly integrates runtime, communication and management layers providing high performance and reliable environment for enterprise usage.

Simple in usage and powerful inside to enable new possibilities, to enable the unreachable.

How it works ?

Multi-JVM architecture, where every microservice is run using separate JVM process to ensure it’s autonomy and isolation – the most important principles in microservices architecture. No more StackOveflowError or OutOfMemoryError propagated through whole application – different JVMs mean different memory space and thread pool. Every JVM process is fully controlled in scope of management and monitoring by the platform built-in process manager. Micrservices communicate with each other through federated, distributed service bus.
Spring Framework supported by default, which means that JLupin Microservice (springApp) consists of plain Java classes controller by the Spring IoC and packed into handy jar files. No JLupin specific annotations are required to expose remote services. Pure Spring, fully portable between Java application platforms. This approach comes from the main goal of JLupin Next Server - transparently met all infrastructural demands necessary to run application as microservices in distributed environment. Write code in Java , configure with Spring ? Need microservices ? JLupin Next Server is just for you – try it !
Binary interfaces for high performance communication with microservices (ex. from frontend components as well as between them). This is the key feature to guarantee highest quality for data processing, especially where many interactions between microservices are taken into consideration. In case when one frontend request triggers over hundred requests between microservices the couple of milliseconds matters, really.
Elastic API to get microservice’s functions easier and faster when binary protocols are not an option. You will be able to choose the proper data format (JSON / XML) and interface semantics (SOA vs REST) on the same port. Thanks to compatibility with the OpenAPI Specification (aka the Swagger Specification) you will be able to use Swagger tools to visualize and interact with your services running on JLNS without having any of the implementation logic in place. This is a great addition to the very fast binary interfaces (sync / async), already available in JLNS. Read more about Elastic API to accelerate your application’s integration.
Queues which are deeply integrated with the platform to enable asynchronous mode of microservice’s invocation and message driven programming They are available through binary protocol and automatic interfaces (see below). We’ve paid a lot of attention to its performance to ensure high capacity for message-driven communication. The most important thing is that…. they are onboard, ready to use, out-of-the-box. Go to documentation to learn how to use it in practice.
Automatic interfaces to provide microservices’ functionalities in the environment without ANY programming effort. What’s more, these interfaces allows usage of various protocols available in JLNS – http (Elastic API) and binary (synchronous and asynchronous). This means that the same piece of your code can be remotely invoked through variety of protocols, depends on your needs and application’s architecture. No more struggling with translation layer of your application ! Interesting ? Do you need more ? Go to documentation.
JLupin Resource Brick (jBrick) technology to meet any performance demands and scale of operations. New resource management mechanism allows traffic offloading for very demanding microservices and increases total capacity of the IT system. Do you need to run Netflix.com on JLupin Next Server ? No problem, just do it. This is the base of JLupin Next Server's architecture and if you like to get to know more, please refer to this chapter in documentation.
Zero downtime deployment mechanism means real, online microservice upgrade without risks and constraints. A new version of a microservices is initialized as a new JVM process, and after it is ready to handle traffic, the platform redirects request to this new version. The old version is turned off after all request are finished. Clear, safe, easy and... completely online.
Self-healing actions to minimize application downtime. Every JLupin Microservice is monitored for StackOverflowError and OutOfMemoryError errors and if one of these occures the JLupin Next Server restarts the microservice with 15% additional resources (JVM threads & memory) to extend the time needed for collecting the necessary data for analysis in case of an incident or to prepare microservices farm to handle more traffic (vertical scalling).
Java servlets / JSP through SpringBoot integration to enable web microservices and move JLupin Next Server from middleware class solutions to full-stack application platform to run any kind of IT systems in microservices architecture. Java servlets give you also opportunity to implement your own API and run JLNS in the IT environment where backward compatibility is needed. If you have a monolith in .war file and you think of splitting in into microservices, please read this article how it could be done on JLupin Next Server.
Load balancers should be treated as a key component in microservices platform. On JLupin Next Server they are provided as integrated unit providing reliable and high performance communication with or between microservices. It uses advanced metrics and algorithms in balancing mechanisms to fit any traffic demands and characteristics. Would like to get to know more ? – go to documentation.
Service Repository & Discovery which gives you full information about what services are running in the environment and which of them are available for clients and other services. This mechanism is deeply integrated with load balancers to provide high reliability for communication and service availability. Detailed description how it works is located here.
Powerful IDE plugin (IntelliJ) to support planning and developing IT systems in microservices architecture. It let you easily add new microservices to your project, visualize it in your Intellij and check relations between your services. This absolutely unique solution on the market, which significantly accelerates your effectiveness as a developer. Need more time for exploring new microservices design patterns ? Need more time for your interests ? Get it now and learn how to use it.
Enhanced management through new CLI console and YAML configuration files. It assumes new flexible architecture model, where jBricks are managed in zones and gives full control over your infrastructure and applications. Designing the console we paid special attention to the user experience. See if we have achieved a new quality in CLI consoles -> try it now (enterprise section) and read about its management capabilities !

Why JLupin Next Server ?

You don’t ned to integrated dozens of different libraries, components, technologies – no more need for specialist in every single one of them, everything is on board, simple and ready to use.
Why to run huge application server for every single microservice with complicated configuration files? JLNS is already spawning microservices a separate OS processes without this overwhelming resource wasting.
Managing microservices can be done through CLI console. There is no need for logging into every single machine in your cluster.
Do you need to monitor your microservices? It’s not a problem. Health checking is already there.
Do you need to restrict resources for your microservices but don’t want to add extra runtime layer like docker or struggle with groups? Just configure your microservice to use limited amount of memory and threads.
With IDE plugin the process of planning and developing applications in microservices architecture are strongly supported
The whole platform with your microservices can be run on a single computer, ex. on your workstation as development environment.
No more special and complicated build scripts to create distributable version of microservice. In JLupin it is just a jar file with optional dependencies and configuration file. It is simple as it is.
You have strong support to fix problems fast and easy.
You can start the journey with microservices smoothly, from running your monolith as a microservice and then starting the process of smashing it into smaller pieces.
Just write your microservices – don’t bother about the rest under the hood.
The performance is not an issue anymore…

Well... If you reached this place you seem to be ready to try... are you ? Let's do it !