Microservices make it much easier to implement and understand a single service. But they also introduce new problems. You now have a system of independent services that need to interact with each other but do not depend on each other. Suddenly, exchanging data between services and orchestrating complex business operations becomes a complicated process.
As a consultant and trainer, I have worked with developers in various companies. Sooner or later, all of them struggle with this new, often unexpected complexity.
But what makes communication between microservices so tricky?
In a monolithic application, we implemented complex use cases by calling methods in various parts of our application. Now we split and distribute the functionality over multiple services. Instead of calling a method, we now need to call a remote service.
Sure, we try to design our services so that we minimize the number of calls to other services. But we can't avoid them entirely. So, we need reliable and scalable communication between our services.
Exchanging data is much harder than it seems
The main challenges, when exchanging data between services, are to avoid scalability issues and to ensure data consistency. The tools that we used in monolithic applications no longer provide the right solutions for that. With them, you need to choose between scalability and data consistency.
Distributed transactions are a typical example of that. They ensure consistency, but they rely on locks, which create scalability issues. That's why a lot of modern data stores no longer support them.
Some teams, therefore, decide to use multiple local transactions. This is called a dual write, and you should avoid it at all costs. It might be easy to implement and provide great scalability, but it puts data consistency at risk.
That's where a lot of developers get stuck. The old patterns are no longer good enough. But that doesn't mean that you can't build a scalable and reliable system of microservices.
New patterns and tools to ensure consistency and scalability
Over the last few years, our industry has developed new patterns and tools to solve these issues. These new patterns enable you to get scalability and data consistency at the same time. I've helped lots of teams to apply these patterns in their microservices. After a quick introduction and a few examples, they were able to easily solve one of their biggest struggles:
Communication between their services.
And they were finally able to reap the benefits of a microservices architecture. They focused on the business logic of each service and no longer worried about communication between them.
In this course, I want to offer you the same learning experience. We will start with the essential requirements and communication concepts for microservices. Then we will take a look at synchronous and event-based approaches to sharing data between services, compare different options to ensure consistency during distributed update operations, and take a look at event-focussed strategies to manage your data.
Create reliable and scalable applications
Having completed this course, you will be well prepared to design and implement robust and scalable microservice applications.
Instead of hoping that everything goes well and that none of your services fail, you will be able to use modern patterns that were developed for scalable and highly-distributed microservices. You will know how to design your services and the communication between them to ensure data consistency, robustness, and scalability.
Your new skills will not only improve the way you write software. They will also establish you as a true expert within your team. With your expertise on modern software development, you will be well-prepared to take on new, interesting tasks and to grow your technical career.
Join now to get a structured, in-depth introduction to the new patterns specifically designed for microservices.
I taught the material of this course several times times in the form of an in-person workshop before I recorded this new online course. Every time I taught the workshop, I got amazing feedback.
But don't just take my word for it. Here is what other people say:
This workshop provides you with a good foundation on techniques and architectural options for microservices and gives you a solid understanding of their benefits and drawbacks. Thorben focusses on really problematic topics that are often ignored during conference talks, e.g., data synchronization/consistency and error handling. These problems are often complicated and require tailored solutions for the selected architecture.
I especially liked the coding exercises with provided solutions. I worked on them during and after the workshop, and I learned a lot. I also enjoyed the detailed discussions about data consistency in a distributed microservice architecture.
I would also recommend this workshop to seasoned architects and I even organized an additional in-house workshop with Thorben as I was very satisfied after participating.
Anders Malmborg // Principal Architect
When you enroll in the Data and Communication Patterns for Microservices course today, you’ll get access to my self-paced video course that teaches you all you need to know about modern patterns for microservices so that you can:
To make the course content easier to consume, I've split it into 9 blocks that I will release weekly. But don't worry, you don't need to follow a fixed schedule. You get lifetime access to all of the training materials so that you can watch and re-watch the lectures whenever you want.
And you are 100% safe when trying this out. That’s all I’m suggesting. Just try the Data and Communication Patterns for Microservices course for 30 days to see if it works for you.
If it does, you'll learn when and how to use each of the modern patterns that have been developed for a microservice architecture. This will make your daily work more enjoyable and prepare yourself for the next step in your career - and I think that's exactly what's about to happen. If, for some reason, you're not happy with the course or if you are still not sure how to use some of the explained patterns, then just let me know that you want to use my Simple & Unconditional 100% Money-Back Guarantee and you'll get 100% of your money back.
The Data and Communication Patterns course consists of 8 modules with 21 lectures with example projects and exercises that show you everything you need to know to ensure data consistency and scalability for your microservice application.
You also get free access to a set of exclusive bonuses that improve your training experience and ensure your long-term success.
But first, let's take a look at the modules and lectures included in the Data and Communication Patterns course.
Learn about the differences between monoliths and microservices and their effect on your persistence layer.
Synchronous service calls look like an easy solution, but implementing them reliably is harder than it seems.
You can avoid synchronous service calls by storing all required information locally.
Standard solutions for asynchronous communication between your services are based on events.
Publishing an event without using a distributed transaction requires new patterns and tools.
If you need to update multiple services, eventual consistency scales much better than global transactions.
Instead of using a relational table model, you might want to store your events in an event store.
If we're talking about event sourcing, we also need to talk about CQRS:
To make this course as effective and flexible as possible, all classes provide you with lifetime access to all of the training videos, example projects, exercises with solutions and all other course materials.
Watch more than 4 hours of Hibernate Performance Training on video.
Get all of the example projects that are used during the course.
Study at your own pace with lifetime access to all training material.
Try what you have learned in practical exercises.
Get a comprehensive handout with commented slides.
Certificate of Completion
Earn a certificate of completion to prove your expertise.
You have a choice to make: Do what you’ve been doing or try something new.
You know the problems you're dealing with. Do you really want to keep worrying about inconsistencies and scalability issues over and over again?
Take a new direction, and get a new result. Start using the new patterns and tools that have been developed to ensure scalability and data consistency in a microservice architecture.
This is more than just a guarantee. It's a promise from a developer (me) to a developer (you).
Take 30 days to study the Data and Communication Patterns for Microservices course and learn how to use new patterns and tools to build scalable and consistent microservices.
If you're not happy with the course or if you are still not sure how to use some of the explained features, send me an email and ask for a refund. After you have logged in, you will find my email address at the bottom of the course page. I will promptly send you 100% of your money back.
Yes, that's right. I'm taking all the risk with this guarantee. You could rip me off by enrolling in the Data and Communication Patterns for Microservices course with the intention requesting your money back after 30 days.
But I trust that you won't do that. We software developers are honest people and don't rip each other off, right?
So, I trust you, and you don't have to take any risks.
Here are answers to some frequently asked questions:
Yes, you will see and work with several code samples.
I will show you several example implementations during the lectures. And while you're working on the exercises, you will extend existing services and implement your own microservices.
You should be familiar with Java, of course ;-) and have at least some basic knowledge of dependency injection, REST APIs and JPA.
We use different open source frameworks that provide ready-to-use implementations of most of the explained patterns.
You can use these frameworks with Spring Boot, Eclipse Microprofile and plain Java SE. During the workshop, I will use Spring Boot to implement the services.
Let's talk about it. Please send me an email to firstname.lastname@example.org.