Data and Communication Patterns
14.-16.09.2021 - Online
Modern patterns for reliable and scalable applications
Design Your Microservices with Confidence!
Microservices make it much easier to implement and understand a single service. But they also introduce new problems. As a consultant and trainer, I have worked with developers in lots of different companies. Sooner or later, all of them struggle with this new, often unexpected complexity.
But what makes the 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 have distributed this functionality over multiple services. Sure, we try to cut our services so that we minimize the number of call to other services.
But we can't avoid them completely. So, we need to implement reliable and scalable communication between our services.
Exchanging data between our services is much harder than it might seem.
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 don't provide good 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. It scales much better, but puts data consistency at risk.
Both approaches are not an option. That's where a lot of developers get stuck. The old patterns no longer work. But that doesn't mean that you can't build a scalable and reliable system of microservices.
Our industry developed new patterns and tools that ensure consistency and scalability!
Over the last few years, 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 solve one of their biggest struggles: The 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 the communication between the services.
In this workshop, 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 share 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.
After participating in this workshop, you will be well prepared to design and implement your microservice application.
Instead of hoping that everything goes well and that none of your services fails, 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.
Join now to get a structured, in-depth introduction to the new patterns specifically designed for microservices, so that you can build your microservice application with confidence.
Now It's Your Turn!
When you enroll in the Data and Communication Patterns Workshop, I will invite you to a video call on September 14th-16th, 2021. The material and level of interactivity of the workshop will be identical to a typical in-person workshop.
I will teach you all you need to know about the patterns for microservices so that you can:
You also get lifetime access to my Data and Communication Patterns Online Training, which is the online version of the workshop. So, whenever you are not exactly sure how to use one of the features I showed you during the workshop, you can watch the corresponding video. This gives you the best of both worlds. You get:
The Data and Communication Patterns Workshop consists of 7 modules with 16 lectures with example projects and exercises that show you everything you need to know to ensure data consistency and scalability in for your microservice application.
Learn about the differences between monoliths and microservices and their effect on your persistence layer.
- Lecture 1:
Requirements of microservices
- Lecture 2:
How to ensure data consistency
Synchronous service calls look like an easy solution, but implementing them in a reliable way is harder than it seems.
- Lecture 3:
API composition based on synchronous service calls
- Lecture 4:
Prevent failure cascadation
- Lecture 5:
Find other services in a dynamically scaled environment
- Lecture 6:
Simplify the implementation of your client services
You can avoid synchronous service calls by storing all required information locally.
- Lecture 7:
Store the required data in a view database
Common solutions for an asynchronous communication between your services are based on events.
- Lecture 8:
Event driven services
- Lecture 9:
Create domain events to replicate your data
Publishing an event without using a distributed transaction requires new patterns and tools.
- Lecture 10:
- Lecture 11:
Implementing the outbox pattern using Debezium
If you need to update multiple services, eventual consistency scales much better than global transcations.
- Lecture 12:
- Lecture 13:
Choreography-based SAGA pattern
- Lecture 14:
Orchestration-based SAGA pattern
Instead of using a relational table model, you might want to store your events in an event store.
- Lecture 15:
- Lecture 16:
Data and Communication Patterns
for Microservices Workshop
9:00 - 17:00 CEST September 14th 2021
9:00 - 17:00 CEST September 15th 2021
9:00 - 17:00 CEST September 16th 2021
(contact me for alternatives)
Online via Zoom
Example projects for all lectures
Practical exercises and solutions
Data and Communication Patterns Online Training
To enroll in the training, please fill out the form below. I will email you a formal quote and an invoice to secure your seat.
Here are answers to some frequently asked questions:
Will we use and create example implementations of the patterns?
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.
What other technologies should I be familiar with?
You should be familiar with Java, of course ;-) and have at least some basic knowledge of dependency injection, REST APIs and JPA.
Which frameworks do you use in the examples and exercises?
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.