On the 22 and 23rd of March I went to the ‘Microservices Conference 2018, MicroXchg’ in Berlin. This blog post is a short recap of my experience of this conference, this year held for the 4th time.
My goal was to learn more about the Microservices world, to fill my toolset of possible architecture solutions and of course to see Berlin a bit. Furthermore, I interviewed Chris Richardson about Microservices and his upcoming book on Patterns. This interview is added to this blog as well.
Note that everything within this blog is purely my own opinion.
The conference was held at Kalkscheune in Berlin. A nice location with big conference rooms. There were 5 different rooms and everything was recorded.
There were 4 parallel sessions with 1 indepth-session. The normal sessions were 50 minutes long: time enough to get some more detailed information and time for questions as well. As my goal was to obtain a global idea of the Microservices world, I did not attend any of the indepth-sessions.
There were 3 types of sessions:
- Technical sessions (i.e. tooling, languages, products): 21 sessions
- Architectural sessions (i.e. modeling, design, architecture): 17 sessions
- Organizational sessions (i.e. impact on organisations): 3 sessions
I did not speak to everyone, but in my opinion the majority of the audience was technical oriented and mostly German. There were also foreign speakers. This gives me the idea that Microservices is still mostly a technical IT party. Maybe not everyone does agree with me on that, but the number of managers and CIOs was nihil or maybe even zero. If you want to use the Microservices architecture style within your organization, there will also be a lot of structural consequences. This was a little bit underexposed within the conference.
Of course there were also a couple of stands of the sponsors of the event.
I went to the conference with a couple of questions. One of them was if the UI is part of a Microservice or not. There were 2 great sessions about this topic from Matthias Laug and Elisabeth Engel. Even the term ‘micro frontends’ was introduced (at least a new term for me). In the talk of Matthias he opt that the front end part should be deployed as 1 microservice, together with the backend part. Aggregation of several Microservices is done using frames and this should be a thin layer.
A talk by Chris Richardson about using Sagas to implement data consistency within Microservices and using local transactions i.s.o. two-phase-commit transactions. Saga uses compensation handling and/or event driven architectures to deal with data consistency. This makes the design of such systems not easier.
An interesting talk by Lutz Huehnken about designing the microservices boundaries using event storming. This is a method where you do not look at the business entities, but at the events that happen within the processes. The focus is more on the dynamics than on the nouns and structures. The events will then lead to the commands needed and which entities (nouns) are involved. He argued that this will lead to better reactive systems as stated within its manifesto (https://www.reactivemanifesto.org/). I think we will use the design techniques that will have the closest relation with the business problem at hand. But thrilled to have new tools available again.
I also read about service meshes so I was curious what this is all about. Fortunately there was a talk about this subject by Daniel Bryant. A service mesh is about the communication between the services. As services can be executed in several containers within even several hosts, the requests must be routed to a service. So runtime service discovery is needed. A service mesh will take care of this. It can also contain some more (business) rules, so that for example European requests are sent to different containers or hosts. Linkedr, Conduit and Istio are some examples of services meshes. However, Daniel warned that care must be taken when using them in production, because they are not mature enough yet. It also sounded to me as the new replacement of the ESB, because it is also a central component within service communication and contains routing rules. Let’s see how these service meshes evolve.
How to be an architect in a Microservices world
This talk was about the architect Felix Muller and his experiences within the Architecture field. For me there were no specific new elements. He talked about (software) architects in teams and an architecture board for alignment. This is not very different in the way organisations already work. Also technical reviews were mentioned which are not specifically new (at least for me). In a truly Microservice architecture you hope to have less alignment because of the self management of the teams and the loose coupled services. In practice I think this will be not the case, because the services will also share common services (i.e. CI/CD pipelines, service meshes, PaaS and IaaS, security ,API gateways).
Patterns and anti-patterns
Stefan Tilkov is a well known speaker and I know him as one of the first RESTefarian. It is always good fun to watch him and he has always good content to think about. His talk was about patterns and anti-patterns. Those patterns are used as a standard for communication and are not part (yet?) of an official pattern catalog. Chris Richardson is also working on Microservices patterns that can be used. The following anti-patterns were discussed:
- Distributed monolith (microservices gone through the roof, getting too complex)
- Decoupling illusion (technical separation does not match the business domain separation)
- Micro platform (standardization of shared functionality)
- Entity Service (wide business entities as boundaries)
- Anemic Service (layering in data services)
- Unjustified re-use (extremely generic utility functions)
- Autonomous cells (decentralized domain focused cells)Size patterns
- Function as a Service (FaaS, small services, serverless)
- microSOA (small self hosted, synchronous)
- Distributed Domain Driven Design (business events)
- Self-contained systems (UI+DB)
Interview with Chris Richardson
One of the speakers of the conference was Chris Richardson, a well known man within the Microservices world. He is currently writing a book on Microservices patterns, and this will be released soon (see also http://microservices.io/patterns/microservices.html). I got the change to meet him and interview him. Here you can see and listen the interview. Be aware, it was my first interview, I was a little bit nervous and I used my phone to record it. Oh, and forgive me for the tight blouse 😉
The following conclusions I would like to point out:
- The conference was visited well, but mainly by technical audience
- A good mix between tooling, frameworks and architecture sessions
- It gave me a good impression about the status of the Microservices architectural pattern, which on the tooling level is still immature on some points (i.e. Service Meshes)
- Hopefully will Service Mesh not be the new ESB hell.
- Breaking down the problem domain in Microservices is hard
- Languages/frameworks emerge that are more closely related to the modeling of events (i.e. eventuate). This means again that the model is within the language itself (just like it was for object oriented design and OO languages)
- Entity modeling and business capabilities modeling are really two different modeling techniques of which entity modeling is the most wrongly? used for modeling Microservices
- CQRS and Event Sourcing are two topics I have to dig into
- There are a lot of (new) terms and tools within the Microservices world
- Hopefully next time all presentations and slides are available on the conference site: http://microxchg.io/2018/index.html
In a next blog I hope to share a Microservices reference architecture with a sheet of possible tools/frameworks/products within a particular concept within that architecture.