Designing Event-Driven Microservices

Integrating microservice patterns

Dive into the world of microservices, where traditional development patterns evolve to meet the needs of a rapidly changing business environment. At first glance, these patterns may seem daunting to many developers. However, as you journey through this course you'll learn how the patterns can enhance your microservice architecture and make your development life easier.

You'll learn about:

• Asynchronous Events: The heartbeat of event-driven systems.
• Publish-Subscribe: A framework for decoupled services.
• The Strangler Fig Pattern: Ensuring legacy systems evolve gracefully.
• Branch by Abstraction: Seamlessly integrating new functionality with minimal disruption.
• The Transactional Outbox: Solving the dual-write problem to ensure integrity.
• CQRS and Event Sourcing: Providing historical context and data integrity.
• And More!

These patterns represent practical solutions to real-world challenges offering a path forward when transitioning from a monolithic architecture to a set of microservices. However, to use them effectively, you need to understand what problems they solve, and how they can be applied.

Unlocking the power of microservices

When used properly, microservices can unlock many advantages such as:

• Scalability: Expand with ease and efficiency.
• Resiliency: Build systems that resist failure.
• Autonomy: Empower teams with the freedom to innovate.
• Flexibility: Adapt swiftly to ever-changing demands.

If provided with the right tools, microservice teams can release new features at a faster rate which fosters a culture of innovation and continual improvement.

A journey from monoliths to microservices

This course will walk through the key principles behind microservices, including many of the patterns needed to be successful. Along the way, it explores a case study of a bank transitioning from a monolithic architecture to microservices. We’ll follow them at each step to see how they might solve the problems they are encountering.

The examples presented will discuss features of Apache Kafka and Confluent Cloud, but the principles can be applied no matter what technology stack you decide on.

Intended audience

• Developers and architects embarking on a transformation to microservice architecture.

Course outline

The course is divided into multiple chapters, each ending with a case study. The case study will take the concepts presented in the rest of the chapter and show how they can be applied in a realistic scenario.

• Chapter 1
  • From Monoliths to Microservices
  • Case Study - Paragon Central Bank
• Chapter 2
  • Autonomous Microservices
  • Data Ownership
  • Case Study - Defining an API
• Chapter 3
  • The Strangler Pattern
  • Branch by Abstraction
  • Polyglot Architecture
  • CI/CD
  • Case Study - Decomposing a Monolith
• Chapter 4
  • Asynchronous Events
  • Commands, Events, and Queries
  • Point-to-Point vs Pub/Sub
  • Scalable and Resilient Microservices
  • Case Study - Asynchronous Events
• Chapter 5
  • The Dual-Write Problem
  • The Transactional Outbox Pattern
  • Event Sourcing
  • Listen To Yourself
  • Case Study - Handling the Dual-Write Problem
• Chapter 6
  • Schema Evolution
  • Case Study - Schema Evolution
• Chapter 7
  • Event-Driven Architecture

Prerequisites

• Required knowledge:
  • Knowledge of standard programming principles is assumed (eg. Object-Oriented Programming, Functional Programming etc).

Length

• Approximately 3 hours.

Staff

Wade Waldron (Course Author)

Wade has been a Software Developer since 2005. He has worked on video games, backend microservices, ETL Pipelines, IoT systems, and more. He is an advocate for Test-Driven Development, Domain-Driven Design, Microservice Architecture, and Event-Driven Systems. Today, Wade works as a Staff Software Practice Lead at Confluent, showing people how to build modern data streaming applications.

LinkedIn