Data and Communication Patterns
for Microservices

Announcement:
Due to the Corona pandemie,
I will host this workshop online!

15.-17.09.2020 - Online
Lindner Congress Hotel Düsseldorf (Germany)

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, we will meet at the Lindner Congress Hotel in Düsseldorf I will invite you to a video call on September 15th-17th, 2020. The material and level of interactivity of the workshop will be identical to the originally planned in-person workshop.

I will teach you all you need to know about the patterns for microservices so that you can:

  • Design and implement the communcation between your microservices,
  • Ensure scalability, robustness and data consistency and
  • Build your microservices with confidence.

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:

  • All your immediate questions answered during the in-person workshop,
  • The opportunity to connect with other developers at a live event and
  • Ongoing access to the course videos so that you can refresh your knowledge whenever necessary.

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:
    Outbox pattern
  • 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:
    SAGA pattern
  • 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:
    Event sourcing
  • Lecture 16:
    CQRS

About the Author

My name is Thorben Janssen, and I'm the author of the Amazon bestselling book Hibernate Tips - More than 70 solutions to common Hibernate problems.

For the last 15 years, I have been using Hibernate and JPA in all kinds of projects. From small ones with very aggressive timelines to huge projects that had to handle thousands of users.

The requirements of these applications were very different and I learned that Hibernate provides good solutions for all of them. You just have to understand the features along with their advantages and disadvantages.

I'm looking forward to showing you how to use Hibernate's advanced features so that you can implement complex persistence requirements with ease.

About the Author

My name is Thorben Janssen, and I'm the author of the Amazon bestselling book Hibernate Tips - More than 70 solutions to common Hibernate problems.

For the last 15 years, I have been using Hibernate and JPA in all kinds of projects. From small ones with very aggressive timelines to huge projects that had to handle thousands of users.

The requirements of these applications were very different and I learned that Hibernate provides good solutions for all of them. You just have to understand the features with their advantages and disadvantages.

​I'm looking forward to showing you how to use Hibernate's advanced features so that you implement complex persistence requirements with ease.

Data and Communication Patterns
for Microservices Workshop

Schedule:

9:00 - 17:00 CEST September 15th 2020

9:00 - 17:00 CEST September 16th 2020

9:00 - 17:00 CEST September 17th 2020

(contact me for alternatives)

Venue:

Online via Zoom

Lindner Congress Hotel in Düsseldorf (Germany) near DUS Airport

Workshop Material:

Example projects for all lectures

Practical exercises and solutions

Comprehensive handout

Participation certificate

Online Course:

Data and Communication Patterns Online Training
(Certification Class)

Single Seat

1799€ 1399€

per Seat (plus 19% VAT)
if you sign up before June 12th, 2020

  • 3 day Data and Communication Patterns for Microservices training with Thorben Janssen
    • Date: September 15th - 17th 2020
    • Online via Zoom
    • Venue: Lindner Congress Hotel in Düsseldorf (Germany) near DUS Airport
    • Catering: Lunch, coffee and snacks during the breaks, beverages during the workshop
  • Example Projects for all Lectures
  • Practical Exercises & Solutions
  • Extensive Handout
  • Video Course: Data and Communication Patterns for Microservices Online Training
  • Participation Certificate

Team Package (3+ Seats)

1699€ 1299€

per Seat (plus 19% VAT)
if you sign up before June 12th, 2020

  • 3 day Data and Communication Patterns for Microservices training with Thorben Janssen
    • Date: September 15th - 17th 2020
    • Online via Zoom
    • Venue: Lindner Congress Hotel in Düsseldorf (Germany) near DUS Airport
    • Catering: Lunch, coffee and snacks during the breaks, beverages during the workshop
  • Example Projects for all Lectures
  • Practical Exercises & Solutions
  • Extensive Handout
  • Video Course: Data and Communication Patterns for Microservices Online Training
  • Participation Certificate

Enroll Now

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.

Please be aware that the workshop only takes place if the minimum number of participants signs up until June 12th, 2020. I will inform you as soon as we reached the required number of signups so that you can make your travel arrangements.

  • Please enter a number from 1 to 10.
  • This field is for validation purposes and should be left unchanged.

FAQ

Here are answers to some frequently asked questions:

Will we use and create example implementations of the patterns?

What other technologies should I be familiar with?

Which frameworks do you use in the examples and exercises?

Didn't find the answer you're looking for?