Course Outline
Day 1: Event-Driven Architecture Fundamentals in Go
- Introduction to EDA
- Defining Event-Driven Architecture
- Contrasting Monolithic, Microservices, and Event-Driven Systems
- Why Go’s concurrency model and lightweight goroutines are well-suited for EDA
- Core Concepts & Advantages
- Achieving decoupling, scalability, and resilience in enterprise environments
- Defining Events, Producers, Consumers, and Event Brokers
- Real-world case studies illustrating Go’s role in high-performance event systems
- CAP Theorem & EDA Trade-offs
- Overview of Consistency, Availability, and Partition Tolerance
- How EDA influences these properties
- Strategies for balancing consistency and availability in Go-based systems
Day 2: Events, Messages, and Communication Patterns in Go
- Types of Events
- Distinguishing between Domain Events and Integration Events
- Synchronous vs. Asynchronous events in Go applications
- Practical Messaging Patterns
- Implementing Publish-Subscribe (Pub/Sub) in Go
- Designing and structuring event payloads using JSON, Protocol Buffers, or Avro in Go
- Event Handling Implementation
- Survey of popular Go libraries and frameworks for messaging
- Code examples: Dispatching and processing events using idiomatic Go patterns
- Practical session: Building a simple event-driven service in Go
Day 3: Messaging Systems & Event Brokers with Go
- Selecting & Integrating Event Brokers
- Overview of leading brokers: Apache Kafka, RabbitMQ, and NATS
- Comparing use cases and best practices for Go-based systems
- Messaging Infrastructure Setup
- Docker Compose configuration for Kafka, RabbitMQ, or NATS
- Configuring topics, exchanges, queues, and channels
- Overview of Go client libraries
- Hands-On Workshop
- Developing a sample Go microservice that produces and consumes events
- Integrating the service with the selected event broker
- Debugging and testing event flows
Day 4: Deployment, Monitoring, & Advanced Go EDA Topics
- Deploying Go EDA Applications on Kubernetes
- Containerizing Go applications for production environments
- Deploying Kafka (or other brokers) on Kubernetes clusters
- Introduction to KEDA (Kubernetes Event-Driven Autoscaling) for scaling event consumers
- Error Handling & Monitoring
- Managing event failures using robust strategies
- Implementing observability in Go services
- Advanced Topics & Q&A
- Exploring Serverless Event-Driven Architectures with Go
- Event Choreography vs. Orchestration: Use cases and design considerations
- Common pitfalls, lessons learned, and industry best practices
- Open Q&A session and interactive troubleshooting
Requirements
- Proficiency in Go (Golang), with specific experience in using goroutines and channels
- Foundational understanding of software architecture models, including monoliths and microservices
- Familiarity with Docker and Docker Compose
- Basic knowledge of REST APIs and core networking concepts
- Experience with command-line tools and Git
- Recommended: Prior exposure to Kubernetes and messaging systems like Kafka, RabbitMQ, or NATS
Target Audience
- Go developers focused on creating scalable, event-driven applications
- Software engineers moving from monolithic or REST-based architectures to asynchronous systems
- DevOps and cloud engineers managing containerized or distributed microservices
- Technical architects and system designers exploring EDA patterns with Go
Testimonials (7)
we write some code in GO and we learn some stuff regarding EDA like events, when and how.
Alin
Course - Event Driven Architecture Custom
It was an interactive course, no time to sleep :)). Also was nice to work in teams and then to debate according to each result.
Alina
Course - Event Driven Architecture Custom
I enjoyed most the discussions and the examples provided so we could reach by ourselves to the conclusions he wanted to share with us. I liked the pace, the english, the patience, that even if we did not came with the best answer he would not say it is wrong, but came with examples of what could be better.
Simona
Course - Event Driven Architecture Custom
The open discussions and going from understanding the problems/reasons (the `why`) to `EDA`.
Constantin
Course - Event Driven Architecture Custom
the approach of presenting things heavily based on interaction and examples
Virgil
Course - Event Driven Architecture Custom
The interactive nature of the course The self-discovery learning approach where you found answers yourselves The practical focus with real-life examples that made concepts more relatable
Roxana Sandu
Course - Event Driven Architecture Custom
Very interactive. The trainer was very knowledgeable and patient.
