I thought I knew Microservices

So my wife showed this post that floated in Social Media and it goes something like this “ What was that one book that made you cry … “. and I didn’t look at the answers but I can only imagine that it had titles like “Me Before You” or “ A Little Life “ maybe and there was this one book mentioned “ Introduction to Algorithms by CLRS”, it was pretty hilarious and I’m pretty sure it was sarcastic.

But when asked me the same question, as a reader I think I won’t say I cried, but the feeling of getting elevated, inclined so much and admired such a concise work of Chris Richardson’s — Microservice Patterns and that will be a book I will mention.

When I want to write about this book I’m just all over the place and want to make sure I inject you with that one shot that will make you pick this book. The examples of this book are in Java but man its technology agnostic and a must-read for any engineer out there.

Of course, there are a few things I didn't like about the book. Will mention towards the end.

So I was pretty assertive of my Microservices knowledge but I had this question like are we not doing things the Spring/Netflix way. But what about non-JVM communities. So as Michael Scott from The Office says talks about CPR,

Michael Scott: We found ourselves on the, less prepared side of things when Stanley’s heart went bezerk. And I knew exactly what to do but in a much more real sense I had no idea what to do.

I had no idea until reading this book like what are the salient decisions, flows, choice of tools, frameworks I need to consider when coming up with a microservices solution for a scalable application. If I draw a mind map based on this book’s content it will be pretty convoluted but yet will make sense.

So what will you get out of this book,

• Patterns — A hell lot of them
• Out of the Shelf as well as custom tools that make your life easier
• List of Other book names you need to learn
• Github repo’s you need to look for and you didn’t even know such plugin/tools are being built
• Strong testing strategies — Unit, Integration, Component, End to End
• Frameworks ( Most of us know only Netflix Stack )
• Principles to build your own framework
• At least 3–4 options for every design problem or industry-standard suggestion.
• Every non-blocking option to deliver your services
• An expansive discussion on API Gateway
• A very detailed explanation of why DDD is key and precise examples of Aggregates, Value Object, Entities, and their role and rules you need to adhere to when you develop them.
• How to evolve complex services especially the use of Upcasters.

Not sure if I have covered everything but below is the list of doors the book has opened for me.

• https://eventuate.io/
• https://www.lightbend.com/akka-platform
• https://axoniq.io/
• https://konghq.com/kong/
• https://containo.us/traefikee/
• http://wiremock.org/
• https://spring.io/projects/spring-cloud-contract
• https://eventstore.com/
• https://docs.pact.io/
• https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
• https://martinfowler.com/microservices/
• A bunch of rituals you need to do when you want to go the microservices way.
• https://axoniq.io/event-overview — Training
• https://www.toolsqa.com/cucumber/gherkin/ — For Component and End to End Testing
• https://linkerd.io/
• https://istio.io/
• https://sentry.io/
• https://www.honeybadger.io/
• https://prometheus.io/
• https://zipkin.io/
• https://docs.spring.io/spring-cloud-sleuth/docs/current-SNAPSHOT/reference/html/
• https://www.fluentd.org/
• https://flume.apache.org/

I’m at 80% of this ~500 pages book and can’t wait till I complete this and I’m pretty sure it will emit a new Me and I will keep this post updated as I learn new stuff just from this one book.

I did my meta-learning and decided to get myself trained with the AxonIq platform ( pronounced Axonick), its 16 hours of training spread over 8 days. I just want to experience it and see what I learn out off it. I Will detail my learnings in a separate blog.

The author is a high-value target for Microservice Knowledge and he wrote the EventuateTram framework to solve almost all the design problems that arise during microservices implementation. So most of the examples use this platform which is what I didn’t like a lot but when you step back all you need is an idea/pattern and he thereby gives you the fishing rod instead of a fish.

Not so long ago my thought was “I understand and spent enough time writing services using RESTful spec using Spring, so how different will microservices be anyways “, I can strongly say that using Spring and Netflix stack will suck out/hide a lot of essential WHY from us engineers.

The author makes sure to mention almost everywhere in the book that this solution is not a silver bullet but solves the problem, but according to me many such solutions when put together will become our silver bullet just enough to kill the problem.

Read this book.

Vinodh