Back To Course Home

Event-Driven Architecture in Golang

0% completed

Overview

About This Course

Introduction to Event-Driven Architectures

Introduction EDA Patterns EDA Core Components The MallBots Application Benefits of EDA Challenges of EDA Summary Quiz: Event-Driven Architecture

Supporting Patterns in Brief

Introduction Domain-Driven Design All About DDD Modeling and Key Patterns of DDD Architectural Evolution: Traditional to Domain-Centric Hexagonal Architecture: Testing and Adaptation Strategies Command and Query Responsibility Segregation Application Architectures Summary Quiz: Supporting Patterns

Design and Planning

Big Picture EventStorming

Steps One and Two: Kick-Off and Chaotic Exploration

Step Three: Enforcing the Timeline

Step Four: People and Systems

Step Five: Explicit Walkthrough

Final Step: Problems and Opportunities

Design-Level EventStorming

Understanding the Business

Recording Architectural Decisions

Quiz: Design and Planning

Event Foundations

Introduction A Tour of MallBot Module Code Organization Composition Root User Interface Module Integration Types of Events Domain Events: Efficient System Adaptation Domain Events Optimization: Handling Efficiency Summary Quiz: Event Foundations

Tracking Changes with Event Sourcing

Introduction Event Sourcing Adding Event Sourcing to the Monolith Updating the Monolith Modules Adding the Event Sourcing Package Aggregate Repositories and Event Stores Implementing the Event Store Using Just Enough CQRS: A Group of Stores Using Just Enough CQRS: A Group of Products Connecting the Domain Events with the Read Model Aggregate Event Stream Lifetimes Using Snapshots Summary Quiz: Tracking Changes with Event Sourcing

Asynchronous Connections

Introduction Asynchronous Integration with Messages Event Integration with Notification Events and State Transfer Eventual Consistency Message Delivery Guarantees Message Delivery: Idempotent Messages Message Delivery: Ordered Messages Implementing Messaging with NATS JetStream The am and jetstream Packages Making the Store Management Module Asynchronous Publishing Messages From the Store Management Module Receiving Messages in the Shopping Baskets Module Summary Quiz: Asynchronous Connections

Event-Carried State Transfer

Chapter’s Introduction

Enhancing Module Interaction: Async API Implementation

Enhancing Resilience with Async Fallbacks

Customer State Transfer

Order Processing and Payments State Transfer

Documenting the Asynchronous API

Adding a New Order Search Module

Building Read Models from Multiple Sources

Quiz: Event-Carried State Transfer

Message Workflows

Introduction Distributed Transaction Comparing Various Methods of Distributed Transactions Types of Sagas Implementing Distributed Transactions with Sagas SEC Package Addition and Order Creation Process Conversion The Customers Module The Depot, Order Processing, and Payments Modules Implementation of the Create Order Saga Execution Coordinator Enhancing Order Processing with Orchestrated Sagas Summary Quiz: Message Workflows

Transactional Messaging

Introduction Identifying Problems Faced by Distributed Applications Exploring Transactional Boundaries Setting Up a Container Dependency Injection for Modules Using Containers Transactional DI: Adapter and Handler Optimization Using an Inbox for Messages Using an Outbox for Messages Summary Quiz: Transactional Messaging

Testing

Chapter’s Introduction Coming Up with a Testing Strategy Testing the Application and Domain with Unit Tests Creating and Using Test Doubles in Our Tests Testing Dependencies with Integration Testing Testing ProductCacheRepository Breaking Tests into Groups Testing Component Interactions with Contract Tests Contract Testing with Pact REST Consumer and Provider Example Message Consumer and Provider Example Testing the Application with End-to-End Tests Making Executable Specifications Out of Our Features Summary Quiz: Testing

Deploying Applications to the Cloud

Introduction Turning the Modular Monolith into Microservices Updating the Composition Root of Each Module Updates to the Dockerfile Build Processes Adding a Reverse Proxy to the Compose Environment The Necessary DevOps Tools Using Terraform to Configure an AWS Environment Deploying the Infrastructure Deploying the Application to AWS with Terraform Summary Quiz: Deploying Applications to the Cloud

Mini Project

Application Deployment on AWS with Terraform

Monitoring and Observability

Introduction What are Monitoring and Observability?Instrumenting the Application with OpenTelemetry and Prometheus Adding Metrics to the Application Viewing the Monitoring Data Summary Quiz: Monitoring and Observability

Appendix

Setting Up the Local Environment Installing the Necessary DevOps Tools

Chapter’s Introduction

Get an overview of what we will cover in this chapter.

We'll cover the following

Chapter overview

We added NATS JetStream to our application as our message broker. We also added the ability to publish messages from the Store Management module and added message consumers to the Shopping Baskets module. For now, we are only logging the messages as they are consumed, and that will be changing in this chapter.

Chapter overview

We are going to cover the following main topics as illustrated in the figure below:

Get hands-on with 1400+ tech skills courses.