Book Image

Event-Driven Architecture in Golang

By : Michael Stack
5 (1)
Book Image

Event-Driven Architecture in Golang

5 (1)
By: Michael Stack

Overview of this book

Event-driven architecture in Golang is an approach used to develop applications that shares state changes asynchronously, internally, and externally using messages. EDA applications are better suited at handling situations that need to scale up quickly and the chances of individual component failures are less likely to bring your system crashing down. This is why EDA is a great thing to learn and this book is designed to get you started with the help of step-by-step explanations of essential concepts, practical examples, and more. You’ll begin building event-driven microservices, including patterns to handle data consistency and resiliency. Not only will you learn the patterns behind event-driven microservices but also how to communicate using asynchronous messaging with event streams. You’ll then build an application made of several microservices that communicates using both choreographed and orchestrated messaging. By the end of this book, you’ll be able to build and deploy your own event-driven microservices using asynchronous communication.

Related Content you might be interested in

Current Title:

Small book image
Event-Driven Architecture in Golang
Michael Stack
Nov, 2022 | 6 hours 24 minutes
Small book image
Domain-Driven Design with Golang
Matthew Boyle
Dec, 2022 | 204 pages
Small book image
Domain-Driven Design with Java - A Practitioner’s Guide
Karthik Krishnan | Premanand Chandrasekaran
Aug, 2022 | 302 pages
Small book image
Hands-On Domain-Driven Design with .NET Core
Alexey Zimarev
Apr, 2019 | 446 pages
Table of Contents (18 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share Your Thoughts
Download a free PDF copy of this book
1
Part 1: Event-Driven Fundamentals
Part 1: Event-Driven Fundamentals
Free Chapter
2
Chapter 1: Introduction to Event-Driven Architectures
Chapter 1: Introduction to Event-Driven Architectures
Technical requirements
An exchange of facts
The MallBots application
Benefits of EDA
Challenges of EDA
Summary
3
Chapter 2: Supporting Patterns in Brief
Chapter 2: Supporting Patterns in Brief
Domain-driven design
Domain-centric architectures
Command and Query Responsibility Segregation
Application architectures
Summary
Further reading
4
Chapter 3: Design and Planning
Chapter 3: Design and Planning
Technical requirements
What are we building?
Finding answers with EventStorming
Understanding the business
Recording architectural decisions
Summary
Further reading
5
Part 2: Components of Event-Driven Architecture
Part 2: Components of Event-Driven Architecture
6
Chapter 4: Event Foundations
Chapter 4: Event Foundations
Technical requirements
A tour of MallBots
Taking a closer look at module integration
Types of events
Refactoring side effects with domain events
Summary
7
Chapter 5: Tracking Changes with Event Sourcing
Chapter 5: Tracking Changes with Event Sourcing
Technical requirements
What is event sourcing?
Adding event sourcing to the monolith
Using just enough CQRS
Aggregate event stream lifetimes
Summary
8
Chapter 6: Asynchronous Connections
Chapter 6: Asynchronous Connections
Technical requirements
Asynchronous integration with messages
Implementing messaging with NATS JetStream
Making the Store Management module asynchronous
Summary
9
Chapter 7: Event-Carried State Transfer
Chapter 7: Event-Carried State Transfer
Technical requirements
Refactoring to asynchronous communication
Adding a new order search module
Building read models from multiple sources
Summary
10
Chapter 8: Message Workflows
Chapter 8: Message Workflows
Technical requirements
What is a distributed transaction?
Comparing various methods of distributed transactions
Implementing distributed transactions with Sagas
Converting the order creation process to use a Saga
Summary
11
Chapter 9: Transactional Messaging
Chapter 9: Transactional Messaging
Technical requirements
Identifying problems faced by distributed applications
Exploring transactional boundaries
Using an Inbox and Outbox for messages
Summary
12
Part 3: Production Ready
Part 3: Production Ready
13
Chapter 10: Testing
Chapter 10: Testing
Technical requirements
Coming up with a testing strategy
Testing the application and domain with unit tests
Testing dependencies with integration testing
Testing component interactions with contract tests
Testing the application with end-to-end tests
Summary
14
Chapter 11: Deploying Applications to the Cloud
Chapter 11: Deploying Applications to the Cloud
Technical requirements
Turning the modular monolith into microservices
Installing the necessary DevOps tools
Using Terraform to configure an AWS environment
Deploying the application to AWS with Terraform
Summary
15
Chapter 12: Monitoring and Observability
Chapter 12: Monitoring and Observability
Technical requirements
What are monitoring and observability?
Instrumenting the application with OpenTelemetry and Prometheus
Viewing the monitoring data
Summary
16
Index
Index
Why subscribe?
17
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts
Download a free PDF copy of this book

To get the most out of this book

This book is written with the expectation that you can execute the demonstration application to understand and view the code changes that have been made in each chapter as the application is refactored. To get the most out of the book, it is recommended you read the chapters in order, as the chapters will reference code that has been modified in the previous chapter.

Software/hardware covered in the book

Operating system requirements

Go 1.18+

Windows, macOS, or Linux

Docker 20.10.x

Windows, macOS, or Linux

NATS 2.4

Windows, macOS, or Linux

Most of the development for this book was done in Windows 10, but the code was tested to run in Windows Subsystem for Linux 2 (WSL 2) in Ubuntu 20.04 and tested to run on a Mac. You are expected to run the application and its dependencies within a Docker compose environment. Instructions to use Docker are given wherever possible to minimize installing new software on your machine.

If you are using the digital version of this book, we advise you to type the code yourself or access the code from the book’s GitHub repository (a link is available in the next section). Doing so will help you avoid any potential errors related to the copying and pasting of code.

You can follow the author on GitHub (https://github.com/stackus) or make a connection with them on LinkedIn (https://www.linkedin.com/in/stackmichael).

Previous Section
Next Section