Spring Cloud for Microservices Compared to Kubernetes
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.
Recently I read a great article about building Microservice Architectures With Spring Cloud and Docker by A. . 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:
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.
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.
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.
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.
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).
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.
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 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.
- 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.
- 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 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.
- 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.
- 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.
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.
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.
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.