Week #45's Wednesday Evening Training: Microservices - What, why and how?

Tonight it's Sinterklaasavond in Holland, so there is no Wednesday Evening Training. Hence a good time to settle my debt and write a blog article on week #45's Wednesday Evening Training. I had not finished it yet.

Microservices: what are we talking about?

A Microservice is a variant of the service-oriented architecture (SOA) architectural style that structures an application as a collection of fine grained, loosely coupled services using lightweight protocols. These services can be deployed separately, so that development can be parallelized enabling small autonomous teams to develop, deploy and scale services independently. This allows the architecture of individual services to emerge through continuous refactoring and enables continuous delivery and deployment.

Dividing an application into small pieces also gives additional challenges. Coordination, flow control, integration, monitoring and exception management for example, will have to be supported separately. That is why a Microservice architecture should be provided with Microservices that take on such tasks. Needless to say that correct application of architecture patterns is crucial here.
Besides implementation, activities like testing also gives some extra challenges.

In addition, to make deployment easier, special platforms can be used to easily deliver and deploy Microservices. A good example of such a platform is Docker, that enables Containerization. We've planned some Wednesday Evening Trainings to take a dive in Docker in the upcoming months. Make sure you don't miss my blog posts on these sessions!

I'll be writing more on Microservices in a separate blog post I'll be writing shortly (promise!).

Back to this evenings Wednesday Evening Training...

In this session, Bart van Beek (one of our top Java developers) and I explained the basics of Microservices both from coding and architectural perspective. We've also taken a deep dive into code and did walkthrough of a real project (Java) with one of our clients. There was plenty of opportunity for Q&A and discussion.

We'll be definitely plan additional sessions on Microservices, since this architecture is here to stay and there is still much to learn and share to implement this architectural style effectively and efficiently.

Further reading

Do you want to read more on the topics in this post? Here are some links…

Microservices Resource Guide: https://www.martinfowler.com/microservices
Great articles and pattern descriptions of Martin Fowler: https://www.martinfowler.com/articles/enterprisePatterns.html
Microservice Design Patterns Catalog: http://microservicepatterns.org
Microservice Architecture Tutorial: https://www.tutorialspoint.com/microservice_architecture/index.htm
Designing, building, and operating microservices on Azure: https://docs.microsoft.com/en-us/azure/architecture/microservices
.NET Microservices: Architecture for Containerized .NET Applications: https://docs.microsoft.com/en-us/dotnet/standard/microservices-architecture
Microservices architecture style (challenges, best practices, etc.): https://docs.microsoft.com/en-us/azure/architecture/guide/architecture-styles/microservices

Past Wednesday Evening Trainings on all topics

You 'll find post of previous sessions here: https://www.linkedin.com/search/results/content/?keywords=%23wednesdayeveningtraining


#wednesdayeveningtraining #capgemini #lifeatcapgemini #microservices

This week's Wednesday Evening Training: Microservices architecture and implementation in Java

A bit of architecture and a lot of code this week's Wednesday Evening Training. Together with Bart van Beek, one of our expert Java software engineers, I gave explanation on the architecture, design and engineering of a Microservices architecture.

So what is this "Microservices" architecture?

Let me give you a very, very, very short introduction. See the links in the bottom of this article for further reading & coding.

Since the creation of the first applications, we've continously been attempting to divide an application in manageable parts, so that we could design, develop, deploy and manage applications more effectively and efficiently. This is crucial because solutions nowadays more resembles a continuously changing eco system, rather than a stable and easily manageable one-piece software. Web services have made it possible to connect full applications over the internet in a standardized way, Microservices take this a step further. Microservices are deployed as a light weight, but fully functional applications with very limited functionality. Connected, they form fully functional capabilities (ready to use functionality and data) of which the parts can be changed, deploy and managed independently of each other. This enables continuously changing and deploying sofware parts by independend teams, in different technologies (e.g. Java, .NET) and scaling more easily by deploying the parts on different locations. Using virtual infrastructure and containers (e.g. Docker) you will be able to scale in and out very fast so that you can tune your software infrastructure neatly to what you need at a particular moment.

This drastic increase in flexibility comes with it's price: you will need to put more effort in implementing functionality like communication, coordination, orchestration, monitoring and exception handling that is normally handled in application and integration platforms. Also, engineers need also to be proficient with infrastructure and business processes, instead of just one programming language and related tools.

Therefore, it is increasingly important to follow patterns (standardized solutions). Luckily, there are a lot of patterns available. See the links in the bottom of this article for some of the resources on patterns.

Back to this evening's training...

After my introduction on Microservices architectures and related patterns, Bart gave us a demo and code walkthrough of a Java based Microservices implementation. We could experiment with the example implementation he provided and learned a lot of this. On the internet, we also found a reference implementation of a (Microsoft) Azure reference implementation. In a follow up we'll do a walkthrough of this implementaion as well, and also create a prototype solution in which we'll implement a Microservices solution using both Java and Microsoft technologies. To be continued...

One of the nice things of the Wednesday Evening Training is that we can decide on the spot which technology to discuss. So an evening that is originally focussed on a particular technology can suddenly be enriched with a completely different topic. One of our colleagues, Quincy Jacobs, had dived into OpenGL. OpenGL is closely related to BabylonJS which can be used combined with Unity3D, on which we already had some workshops. On the spot, we decided to plan an wednesday evening combining these topics, combining explanation on the underlying (3d) concepts and experimenting combining the technologies. Also to be continued...

Further reading

Do you want to read more on the topics in this post? Here are some links...

Introductions:
Microservices: https://en.wikipedia.org/wiki/Microservices
Service Oriented architecture: https://en.wikipedia.org/wiki/Service-oriented_architecture
Microservices vs SOA: https://www.bmc.com/blogs/microservices-vs-soa-whats-difference/
Microservices, a definition of this new architectural term: https://martinfowler.com/articles/microservices.html
Why a microservices approach to building applications? (giving an approach to designing and implementation) https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-overview-microservices
Designing, building, and operating microservices on Azure: https://docs.microsoft.com/en-us/azure/architecture/microservices/

Patterns:
Microservice patterns (explanation and patterns): http://www.microservicepatterns.org/
Cloud patterns (explanation and patterns): http://cloudpatterns.org/

Lots of info on patterns on Wikipedia as well...

Example code:
https://github.com/mspnp/microservices-reference-implementation

By the way: in https://github.com/mspnp (Microsoft patterns & practices on GitHub) you'll find lot's of interesting example code on patterns. Well worth visiting!

Past Wednesday Evening Trainings

You'll find post of previous sessions here: https://www.linkedin.com/search/results/content/?keywords=%23wednesdayeveningtraining

Next Wednesday Evening Training

Next Wednesday Evening Training, we'll have a "klusavond" in which we'll work on our projects. In the photo below, you'll see Aish already busy preparing the hardware :).

#capgemini #werkenbijcapgemini #lifeatcapgemini #wednesdayeveningtraining #microservices #microsoft #java