Top 10 Microservices frameworks for 2020

Top 10 Microservices frameworks for 2020

Image for post

1. Spring Boot with Spring Cloud

Image for post

Spring Boot is popular Java framework for writing Microservices. It provides various extension projects under Spring Cloud to build full stack Microservices. Spring Boot allow large scale systems to be built up by starting simple architecture from a number of collaborating components. It can be used to build small as well as large scale system. Spring boot is very easy to integrate with other popular framework also due to Inversion of Control.

Data Management ? Spring have various modules to easily integrate with popular databases. Spring JDBC, Spring JPA, Spring MongoDB , Spring Apache Cassandra are few extensions.

Strategies for Handling Failure ? Spring boot can be easily integrated with Resilience4J. It provides various functionalities to handle failure in distributed system. Circuit breakers, Retry, Timeout,Rate Limiters,fallback handler,Bulkheads etc.

Observability ? Spring Boot Actuator are powerful, it provides health check, view logs, Metrix.

Communication Style ? Spring have capabilities to build reactive app. It is super easy to build rest API with the help of Spring MVC. Spring is easy to integrate with MQ to build asynchronous style services. Spring also have module to build SOAP based application.

Middle-tier Integration ? With the help of various module Spring provide abstraction to integrate with Apache Kafka, any AMQP, RabbitMQ, ActiveMQ

Integration with Tools ? Consul, Prometheus, Jaeger, Grafana

Cloud Native Support ? Easy to deploy on Docker, Kubernetes, OpenTracing, Etcd, DevOps

Security ? Spring Security, good support for OAuth2, Session management, possible to build stateful and stateless services. key vault, Gateway patterns

Distributed config management ? Spring Cloud Config

Service Discovery ? Client Side, Server Side

Performance ? Catching support, Load Balancing, Clustering with Spring Cloud Cluster

Communication Data Format ? JSON, XML

Testing ? Spring Testing module, Mocking, Profiling

Learning Curve ? Easy to learn due to modularity

2. Eclipse Vert.X Microservices framework

Image for post

An another popular Microservices services framework from Eclipse foundation. This frameworks supports multiple languages. So if any organization has Java and Kotlin, JavaScript developers this microservices framework should be their ideal choice. Vertx is a tool-kit for building reactive microservices runs on the JVM.

Eclipse Vert.x is event driven and non blocking. This means your app can handle a lot of concurrency using a small number of kernel threads. Vert.x lets your app scale with minimal hardware.

Some of the cool features Vert.x provides

  • Vert.x is lightweight ? Vert.x core is around 650kB in size.
  • Vert.x is fast. Here are some independent numbers.
  • Vert.x is not an application server. There?s no monolithic Vert.x instance into which you deploy applications. You just run your apps wherever you want to.
  • Vert.x is modular ? when you need more bits just add the bits you need and nothing more.
  • Vert.x is simple but not simplistic. Vert.x allows you to create powerful apps, simply.
  • Vert.x is an ideal choice for creating light-weight, high-performance, microservices.

Vert.x offers various components/Libraries to build Microservice applications. Some of them are listed here.

Vert.x Service DiscoveryThis component lets you publish, lookup and bind to any type of services.

Vert.x Circuit BreakerThis component provides an implementation of the circuit breaker pattern for Vert.x

Vert.x ConfigThis component provides an extensible way to configure Vert.x applications.

Clustering ans ScalabilityVert.x supports clustering and HA out of the box. Cluster group management is implemented in cluster managers which are pluggable. The default cluster manager uses Hazelcast. But you have options like Apache Zookeeper,Ignite also.

ObservabilityVert.x Health Checks component provides a simple way to expose health checks. Health checks are used to express the current state of the application in very simple terms: UP or DOWN. The health checks can be used individually, or in combination to Vert.x Web or the event bus.

TestingVertx Unit is designed for writing asynchronous unit tests with a polyglot API and running these tests in the JVM. Vertx Unit Api borrows from existing test frameworks like JUnit or QUnit and follows the Vert.x practices.

gRPC SupportVert.x gRPC is a module that will align the programming style of Google gRPC with Vert.x style.

Service ProxiesWhen you compose a Vert.x application, you may want to isolate a functionality somewhere and make it available to the rest of your application. That?s the main purpose of service proxies. It lets you expose a service on the event bus, so, any other Vert.x component can consume it.

DevopsVert.x offers various component to keep your Vert.x application on track when running in production e.g. Micrometer, Dropwizard.

There is a big advantage of Vert.x over Spring boot is , Vert.x is Polyglot.

3. Oracle Helidon Microservices framework

Image for post

Helidon microservices framework developed by Oracle. Helidon is a collection of Java libraries for writing microservices. There are two variant, Helidon MP and Helidon SE. If we compare Helidon with Spring Boot, Spring boot out perform many features. Helidon is quite new and not lots of documentation available at the moment and sometime hard to find solution on stackoverflow.

Helidon MP is an implementation of the MicroProfile specification. This makes it a good choice for Java EE developers.

Helidon SE is a compact toolkit that embraces the latest Java SE features: reactive streams, asynchronous and functional programming, and fluent style APIs. Helidon SE supports GraalVM native images for small footprint and lightening fast startup.The REST framework for Helidon SE is the Helidon WebServer. It?s built on top of Netty and uses a straight forward request routing API.

These are few Helidon MP features to build Microservices application

Cloud NativeHelidon libraries interoperate with popular tools from the cloud-native space:

  • Docker and Kubernetes
  • Prometheus, OpenTracing and Etcd

gRPC SupportHelidon gRPC Server provides a framework for creating gRPC applications.

Distributed Config ManagementThe config component provides a Java API to load and process configuration properties in key/value form into a Config object which the application can use to retrieve config data.

Health checks and TracingHealth checks to expose health status that is collected at regular intervals by external tooling, such as orchestrators like Kubernetes. Helidon includes support for tracing through the OpenTracing APIs. Tracing is integrated with WebServer, gRPC Server, and Security.

SecuritySupport Authentication , Authorization and Audit.

4. GoMirco (Golang Microservices framework)

Image for posthttps://en.wikipedia.org/wiki/Go_(programming_language)

Go Micro is a pluggable RPC based library which provides the fundamental building blocks for writing microservices in Go. it implements service discovery using consul, communication via http and encoding using proto-rpc or json-rpc, Pub/Sub.

Go Micro addresses the key requirements for building scalable systems. It takes the microservice architecture pattern and transforms it into a set of tools which act as the building blocks of a platform. Micro deals with the complexity of distributed systems and provides simple abstractions already understood by developers.

Technology is constantly evolving. The infrastructure stack is always changing. Micro is a pluggable toolkit which addresses these issues. Plug in any stack or underlying technology. Build future-proof systems using micro.

Features

The runtime is composed of the following features:

  • API Gateway: The micro api provides powerful routing via discovery and pluggable handlers to serve http, grpc, websockets, publish events and more.
  • Interactive CLI: The CLI gives you all the commands you expect to understand what?s happening with your micro services.
  • Service Proxy: A transparent proxy built on Go Micro and the MUCP protocol. Offload service discovery, load balancing, message encoding, middleware, transport and broker plugins to a single a location. Run it standalone or alongside your service.
  • Service Templates: Generate new service templates to get started quickly. Micro provides predefined templates for writing micro services. Always start in the same way, build identical services to be more productive.
  • SlackOps Bot: A bot which runs on your platform and lets you manage your applications from Slack itself. The micro bot enables ChatOps and gives you the ability to do everything with your team via messaging.
  • Web Dashboard: The web dashboard allows you to explore your services, describe their endpoints, the request and response formats and even query them directly.

5. Molecular (NodeJS Microservices framework)

Image for post

Molecular is an interesting microservices framework. As NodeJS is becoming popular this framework is best if you are a JavaScript developer. Moleculer is a fast, modern and powerful microservices framework for NodeJS. It helps you to build efficient, reliable & scalable services.

Few Main Features

  • Support event-driven architecture with balancing
  • Built-in service registry & dynamic service discovery
  • Load-balanced requests & events (round-robin, random, cpu-usage, latency, sharding)
  • Many fault tolerance features (Circuit Breaker, Bulkhead, Retry, Timeout, Fallback)
  • Built-in caching solution (Memory, MemoryLRU, Redis)
  • Pluggable loggers (Console, File, Pino, Bunyan, Winston, Debug, Datadog, Log4js)
  • Built-in metrics feature with reporters
  • Built-in tracing feature with exporters (Console, Datadog, Event, Jaeger, Zipkin)

6. Quarkus Microservices framework

Image for posthttps://quarkus.io/blog/quarkus-has-a-new-logo/

This framework is pretty new and well suited for Kubernetes lovers. Quarkus is a cloud-native, container-first framework by Red Hat for writing Java applications. Quarkus is a Kubernetes Native Java framework tailored for GraalVM and HotSpot, crafted from best-of-breed Java libraries and standards. The goal of Quarkus is to make Java a leading platform in Kubernetes and serverless environments while offering developers a unified reactive and imperative programming model to optimally address a wider range of distributed application architectures.

Read more on https://www.thoughtworks.com/radar/languages-and-frameworks/quarkus

7. Micronaut

Micronaut is a modern, JVM-based, full stack microservices framework designed for building modular, easily testable microservice applications.

Micronaut is developed by the creators of the Grails framework and takes inspiration from lessons learnt over the years building real-world applications from monoliths to microservices using Spring, Spring Boot and Grails.

Micronaut aims to provide all the tools necessary to build full-featured microservice applications, including:

  • Dependency Injection and Inversion of Control (IoC)
  • Sensible Defaults and Auto-Configuration
  • Configuration and Configuration Sharing
  • Service Discovery
  • HTTP Routing
  • HTTP Client with client-side load-balancing

At the same time Micronaut aims to avoid the downsides of frameworks like Spring, Spring Boot and Grails by providing:

  • Fast startup time
  • Reduced memory footprint
  • Minimal use of reflection
  • Minimal use of proxies
  • Easy unit testing

8. Lightbend Lagom Microservices framework

Image for posthttps://academy.lightbend.com/courses/course-v1:lightbend+LLJ-HelloWorld+v1/about

Lagom is an open source framework for building systems of Reactive microservices in Java or Scala. Lagom builds on Akka and Play, proven technologies that are in production in some of the most demanding applications today.

Lagom?s integrated development environment allows you to focus on solving business problems instead of wiring services together. A single command builds the project, starts supporting components and your microservices, as well as the Lagom infrastructure. The build hot-reloads when it detects changes to source code.

Right-sized services created with Lagom enable:

  • better defined development responsibilities ? to increase agility
  • more frequent releases with less risk ? to improve time to market
  • systems with reactive qualities: responsiveness, resilience, scalability, and elasticticity ? to make best use of modern computing environments and meet demanding user expectations

9. AxonIQ Microservices framework

Image for posthttps://axoniq.io/

Axon provides a unified, productive way of developing Java applications that can evolve without significant refactoring from a monolith to Event-Driven microservices.

Axon includes both a programming model as well as specialized infrastructure to provide enterprise ready operational support for the programming model ? especially for scaling and distributing mission critical business applications. The programming model is provided by the popular Axon Framework while Axon Server is the infrastructure part of Axon, all open sourced.

Axon Framework is a Java microservices framework that helps you build microservices architecture in-line with Domain Driven Design (DDD) principles.

Apart from DDD, Axon Framework also allows you to implement microservices patterns such as Command-Query-Responsibility-Segregation (CQRS) and Event-Driven Architecture.

Axon is ready to meet even the most demanding enterprise requirements like the most efficient scaling of event storage, security, clustering, load-balancing, service discovery, globally distributed data centers, third-party integration, metrics and monitoring.

10. Ballerina Microservices Language

Ballerina is not a framework, it is a distributed programming language to write distributed application. It is build from ground to write decoupled services. It is super easy to write network applications. Ballerina is an open source programming language and platform for cloud-era application programmers to easily write software that just works.

There are a lot more features like threading, streaming, security, and native support for Microservices that I haven?t addressed here.

Overall, Ballerina provides:

  • Language constructs specifically for consuming and providing network services.
  • Abstractions and syntax for concurrency and network interaction that closely correspond with sequence diagrams, which enable bidirectional mapping of Ballerina source code between text and graphical representation.
  • A structural type system that is more flexible and allows for looser coupling than traditional statically typed languages.
  • Design to fit into a modern development lifecycle, including with continuous integration and continuous delivery (CI/CD) tools, such as Jenkins, Travis and Codefresh; observability tools, such as Prometheus, Zipkin and Honeycomb; and cloud orchestration systems like Kubernetes.

import ballerina/http;import ballerina/log;service hello on new http:Listener(9090) {resource function sayHello(http:Caller caller, http:Request req) { var result = caller->respond(“Say Hi to Microservices!”); }}

References

https://practiceoverflow.com

1

No Responses

Write a response