Spring Cloud and
Kubernetes both claim to be the best environment for developing and running Microservices, but they are both very different in nature and address different concerns. In this article we will look at how each platform is helping in delivering Microservice based architectures (MSA), in which areas they are good at, and how to take best of both worlds in order to succeed in the Microservices journey.
Background Story
Recently I read a great
article about building Microservice Architectures With Spring Cloud and Docker by A. Lukyanchikov. If you haven’t read it, you should, as it gives a comprehensive overview of what it takes to create a simple Microservices based system using Spring Cloud. In order to build a scalable and resilient Microservices system that could grow to tens or hundreds of services, it must be centrally managed and governed with the help of a tool set that has extensive build time and run time capabilities. With Spring Cloud, that involves implementing both functional services (such as statistics service, account service and notification service) and supporting infrastructure services (such as log analysis, configuration server, service discovery, auth service). A diagram describing such a MSA using Spring Cloud is below:
MSA with Spring Cloud (by A. Lukyanchikov)
This diagram covers the runtime aspects of the system, but doesn’t touch on the packaging, continuous integration, scaling, high availability, self healing side which are also very important in the MSA world. Assuming that the majority of Java developers are familiar with Spring Cloud, in this article we will draw a parallel and see how Kubernetes relates to Spring Cloud by addressing these additional concerns.
Microservices Concerns
Rather than doing a feature by feature comparison, let’s take a look at wider Microservices concerns and see how Spring Cloud and Kubernetes approach those. A good thing about MSA today is that it is an architectural style with well understood
benefits and trade-offs. Microservices enable strong module boundaries, independent deployment and technology diversity, but they
come at the cost of developing distributed systems and
significant operational overhead. As such, it is a key success factor to bet on and be surrounded by tools that will help you address as much MSA concern as possible. Quick and easy start is important, but the journey to production is a long one, and you need to be
this tall to get there.
Microservices Concerns
In the diagram above, we can see a list with the most common technical concerns (we are not covering the non-technical concerns such as organisation structure, culture and so on) that has to be addressed in a MSA. That is my opinionated view which will vary for different organizations, but for the most part, it should apply to everybody.
Technology Mapping
The two platforms are very different and there is no direct feature parity between them. If we map each MSA concern to the technology/project used to address it in both platforms, we come up with the following table.
Spring Cloud and Kubernetes Technologies
The main takeaways from the above table are:
Spring Cloud has a rich set of well integrated Java libraries to address all runtime concerns as part of the application stack. As a result, the Microservices themselves have libraries and runtime agents to do client side service discovery, load balancing, configuration update, metrics tracking, etc. Patterns such as singleton clustered services, batch jobs are managed in the JVM too.
Kubernetes is polyglot, doesn’t target only the Java platform, and addresses the distributed computing challenges in a generic for all languages way. It provides services for configuration management, service discovery, load balancing, tracing, metrics, singletons, scheduled jobs on the platform level, outside of the application stack. The application doesn’t need any library or agents for client side logic and it can be written in any language.
In some areas both platforms rely on similar third party tools. For example the ELK and EFK stacks, tracing libraries, etc.
Some libraries such as Hystrix, Spring Boot are useful equally well on both environments. There are areas where both platforms are complementary and can be combined together to create a more powerful solution (
KubeFlix and
Spring Cloud Kubernetes are such examples).
Microservices Requirements
In order to demonstrate the scope of each project, here is a table with (almost) end-to-end MSA requirements starting from the hardware in the bottom, up to the DevOps and self service experience at the top and how it relates to Spring Cloud and Kubernetes platforms.
Microservices Requirements
In some cases both projects address the same requirements using different approaches and in some areas one project may be stronger than the other. But there is also a sweet spot where both platforms are complementary to each other and can be combined for a superior Microservices experience. For example Spring Boot provides Maven plugins for building single jar application packages. That combined with Docker and Kubernetes declarative Deployments and Scheduling capabilities makes running Microservice a breeze. Similarly, Spring Cloud has in-application libraries for creating resilient, fault tolerant Microservices using Hystrix (with bulkhead and circuit breaker patterns) and Ribbon (for load balancing). But that alone is not enough, and when it is combined with Kubernetes health checks, process restarts and auto-scaling capabilities turns Microservices into a true antifragile system.
Strengths and Weaknesses
Since both platforms are not directly comparable feature by feature, rather than digging into each item, here are the advantages and disadvantages of each platform summarised.
Spring Cloud
Spring Cloud provides tools for developers to quickly build some of the common patterns in distributed systems such as configuration management, service discovery, circuit breakers, routing, etc. It is build on top of Netflix OSS libraries, written in Java, for Java developers.
Strengths
The unified programing model offered by the Spring Platform itself, and rapid application creation abilities of Spring Boot, give developers a great Microservice development experience. For example, with few annotations you can create a Config Server, and few more annotation you can get the client libraries configure your services.
There is a rich selection of libraries covering the majority of runtime concerns. And since all libraries are written in Java, it offers a multiple features, greater control and fine tuning options.
The different Spring Cloud libraries are well integrated with one another. For example a Feign client will also use Hystrix for Circuit Breaking, and Ribbon for load balancing the requests. Everything is annotation driven, easy to develop and feels like a heaven for Java developers.
Weaknesses
One of the major advantages of the Spring Cloud is also its drawback – it is limited to Java only. A strong motivation for the MSA is the ability to change technology stacks, libraries and even languages when required. That is not possible with Spring Cloud. If you want to consume Spring Cloud/Netflix OSS infrastructure services such as configuration management, service discovery, load balancing, the solution is not elegant. The
Netflix Prana project implements the sidecar pattern to exposes Java based client libraries over HTTP to make it possible for applications written in Non-JVM languages exist in the NetflixOSS eco-system, but it is not very elegant. In addition, since I have written this article, Pivotal has announced a new cool project called
SteelToe, which allows consuming Service Discovery and Config Server services from .Net clients too.
There is too much responsibility for Java developers to care about and the Java applications to handle. Each Microservice needs to run various clients for configuration retrieval, service discovery and load balancing. It is easy to set those up, but that doesn’t hide the build time a runtime dependencies to the environment. For example, I can create a Config Server with @EnableConfigServer annotation easily, but that is only the happy path. Every time I want to run a single Microservice, I need to have the Config Server up and running. For a controlled environment I have to think about making the Config Server highly available and since it can be backed by Git or Svn, I need shared file system for it. Similarly for service discovery I need to start Eureka Server first. For a controlled environment, I need to cluster it with multiple instances on each AZ, etc. It feels like as a Java developer I have to build and manage a not trivial Microservices platform in addition to implementing all the functional services.
Spring Cloud alone has a shorter scope in the Microservices journey, and you will also need to consider automated deployments, scheduling, resource management, process isolation, self healing, build pipelines, etc. for a complete Microservices experience. For this point, I think it is not fair to compare Spring Cloud alone to Kubernetes, and a more fair comparison would be between Spring Cloud +
Cloud Foundry (or Docker Swarm) and Kubernetes. But that also means that for a complete end-to-end Microservices experience, Spring Cloud must be supplemented with something like Kubernetes itself.
Kubernetes
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It is polyglot and provides primitives for provisioning, running, scaling and managing distributed systems.
Strengths
Kubernetes is a polyglot and generic container management platform that is capable of running both cloud native and traditional containerised applications. The services it provides such as configuration management, service discovery, load balancing, metrics collection, log aggregation are consumable by variety of languages. This allows having one platform in the organisation that can be used by multiple teams (including Java developers using Spring framework) and serve multiple purposes: application development, testing environments, build environments (to run source control system, build server, artifact repositories), etc.
When compared to Spring Cloud, Kubernetes addresses a wider set of MSA concerns. In addition to providing runtime services, Kubernetes also lets you provision environments, set resource constraints, RBAC, manage application lifecycle, enable autoscaling and self healing (behaving almost like an
antifragile platform).
I cannot resist myself to mention that Kubernetes technology is based on Google’s 15 years of R&D and experience of managing containers. In addition, with close to 1000 committers, it is one of the most active Open Source communities on Github.
Weaknesses
Kubernetes is polyglot and as such its services and primitives are generic and not optimised for different platforms such as Spring Cloud for JVM. For example configurations are passed to applications as environment variables or amounted file system. It doesn’t have the fancy configuration updating capabilities offered by Spring Cloud Config.
Kubernetes is not a developer focused platform. It is intended to be used by DevOps minded IT personnel. As such, Java developers need to learn some new concepts and be open for learning new ways of solving problems. Despite it being super easy to start a developer instance of Kubernetes using
MiniKube, there is a significant operation overhead to install a highly available Kubernetes cluster manually.
Kubernetes is still a relatively new platform (2 years old) and it is still actively developed and growing. Therefore there are many new features added with every release which may be difficult to keep up with. The good news is that, this has been envisaged, and the API is extensible and backward compatible.
Best of Both Worlds
As you have seen both platforms have strengths in certain areas, and things to improve upon on other areas. Spring Cloud is a quick to start with, developer friendly platform, whereas Kubernetes is DevOps friendly, with a steep learning curve, but covering a wider range of Microservices concerns. Here is a summary of those points.
Strengths and Weaknesses
Both frameworks address different range of MSA concerns, and they do it in a fundamentally different way. Spring Cloud approach is trying to solve every MSA challenge inside the JVM by making it easy for developers to solve it, whereas Kubernetes approach is trying to make the problem disappear for the developers by solving it at platform level. Spring Cloud is very powerful inside the JVM, and Kubernetes is powerful in managing those JVMs. As such, it feels like a natural progression to combine them and benefit from best parts of both projects.
Spring Cloud backed by Kubernetes
With such a combination, Spring provides the application packaging, and Docker and Kubernetes provides the deployment and Scheduling. Spring provides in-application bulkheading through Hystrix thread pools, and Kubernetes provides bulkheading through resource, process and namespace isolation. Spring provides health endpoint for every microservice, and Kubernetes performs the healthchecks and traffic routing to healthy services. Spring externalizes and updates configurations, and Kubernetes distributes the configurations to every Microservice. And this list goes on and on.
My Favourite Microservices Stack
What about my favourite Microservices platform? I like them
both. I like the developer experience offered by the Spring framework. It is all annotation driven, and there are libraries covering all kind of functional requirements. I also like Apache Camel (rather that Spring Integration in this case) for anything to do with integration, connectors, messaging, routing, resilience and fault tolerance at application level. Then for anything to do with clustering and managing multiple application instances I prefer the magical Kubernetes powers. And whenever there is an overlap of functionality, such as for service discovery, load balancing, configuration management, I try to use the polyglot primitives offered by Kubernetes.
About the author:
Bilgin Ibryam is an Apache Camel committer, integration architect at Red Hat, a software craftsman and
blogger. He is an open source fanatic, passionate about distributed systems, messaging and application integration. He is the author of
Camel Design Patterns & Instant Apache Camel Message Routing books.
To learn more, visit our
Linux containers or
microservices Topic pages.
To learn more, visit our
Join the Red Hat Developer Program (it’s free) and get access to related cheat sheets (e.g.
containers), books (e.g.
microservices), and product
downloads that can help you with your microservices and/or container application development.
Related
Deploying Microservices on OpenShift using KubernetesYou’ve heard of microservices. You’ve heard of OpenShift. You’ve heard of Kubernetes. Actually, you may already have considerable experience with each of these three concepts and tools. But do you know how to combine all of them in order to deploy microservices effectively? If not, this article is for you.…
August 16, 2016
In "Containers"
Red Hat sessions at DevNexus 2016 (Atlanta)Here are Red Hat's Session and speakers at DevNexus 2016 in Atlanta this week. Join us at these sessions plus stop by our booth for some good swag! MONDAY, FEBRUARY 15 Docker for Java EE Developers (ALL DAY WORKSHOP) Abstract: Containers are enabling developers to package their applications in…
February 13, 2016
In "Accelerated Development and Management"
Microservices Deployments EvolutionMicroservices Are Here, to Stay A few years back, most software systems had a monolithic architecture and slow release cycle. In the recent years, there is a clear move towards Microservices architecture, which is optimized for scalability, elasticity, failure, and speed of change. This trend has been further enforced by…
