Course Outline
Day 1: Foundations of Event-Driven Architecture in Go
- Introduction to EDA
- The definition and scope of Event-Driven Architecture
- A comparative analysis of Monolithic, Microservices, and Event-Driven Systems
- Leveraging Go's concurrency model and lightweight goroutines for EDA optimization
- Core Concepts & Benefits
- Achieving decoupling, scalability, and resilience in enterprise environments
- Defining Events, Producers, Consumers, and Event Brokers
- Case studies illustrating Go's role in powering high-performance event systems
- CAP Theorem & Trade-offs in EDA
- An overview of Consistency, Availability, and Partition Tolerance
- Assessing the impact of EDA on these system properties
- Methods for balancing consistency and availability in Go-based architectures
Day 2: Events, Messages, and Communication Patterns in Go
- Understanding Event Types
- Distinguishing between Domain Events and Integration Events
- Managing Synchronous vs. Asynchronous events in Go applications
- Messaging Patterns in Practice
- Implementing Publish-Subscribe (Pub/Sub) mechanisms in Go
- Structuring event payloads using JSON, Protocol Buffers, or Avro within Go
- Implementing Event Handling in Go
- A survey of popular Go libraries and frameworks for messaging
- Code demonstrations: dispatching and processing events using idiomatic Go patterns
- Practical session: developing a basic event-driven service in Go
Day 3: Messaging Systems & Event Brokers with Go
- Selecting and Integrating Event Brokers
- Reviewing popular brokers: Apache Kafka, RabbitMQ, and NATS
- Comparing use cases and best practices for Go-based systems
- Setting Up Messaging Infrastructure
- Configuring Docker Compose for Kafka, RabbitMQ, or NATS
- Setting up topics, exchanges, queues, and channels
- Overview of Go client libraries
- Hands-On Workshop
- Developing a sample Go microservice for event production and consumption
- Integrating the service with the selected event broker
- Debugging and validating event flows
Day 4: Deploying, Monitoring, and Advanced Topics in Go EDA
- Deploying Go Event-Driven Applications on Kubernetes
- Containerizing Go applications for production environments
- Deploying Kafka (or alternative brokers) on Kubernetes clusters
- Introducing KEDA (Kubernetes Event-Driven Autoscaling) for scaling event consumers
- Error Handling and Monitoring
- Addressing event failures through strategic approaches
- Implementing observability within Go services
- Advanced Topics & Q&A
- Exploring Serverless Event-Driven Architectures with Go
- Event Choreography vs. Orchestration: Design considerations and use cases
- Common pitfalls, insights, and industry best practices
- Interactive troubleshooting and open Q&A session
Requirements
- Strong proficiency in Go (Golang), specifically with the utilization of goroutines and channels.
- Foundational comprehension of software architecture models, including monolithic structures and microservices.
- Working knowledge of Docker and Docker Compose.
- Basic familiarity with REST APIs and general networking principles.
- Practical experience with command-line interfaces and Git version control.
- Recommended prior exposure to Kubernetes and messaging systems such as Kafka, RabbitMQ, or NATS.
Target Audience
- Go developers focused on constructing scalable, event-driven applications.
- Software engineers shifting from monolithic or REST-centric architectures toward asynchronous systems.
- DevOps and cloud engineers specializing in containerized or distributed microservices.
- Technical architects and system designers investigating EDA patterns through 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.
