Course Outline
Day 1: Fundamentals of Event-Driven Architecture in Go
- Introduction to EDA
- Defining Event-Driven Architecture.
- Analyzing Monolithic, Microservices, and Event-Driven System Architectures.
- Leveraging Go’s concurrency model and lightweight goroutines for optimal EDA performance.
- Core Principles & Advantages
- Achieving decoupling, scalability, and resilience in enterprise environments.
- Identifying Events, Producers, Consumers, and Event Brokers.
- Examining real-world scenarios and case studies featuring Go-powered high-performance event systems.
- CAP Theorem & Architectural Trade-offs
- Reviewing Consistency, Availability, and Partition Tolerance.
- Evaluating the impact of EDA on these critical properties.
- Strategies for balancing consistency and availability in Go-based implementations.
Day 2: Events, Messaging, and Communication Patterns in Go
- Event Classification
- Distinguishing between Domain Events and Integration Events.
- Comparing Synchronous and Asynchronous event handling in Go applications.
- Practical Messaging Patterns
- Implementing Publish-Subscribe (Pub/Sub) models in Go.
- Structuring event payloads using JSON, Protocol Buffers, or Avro within Go projects.
- Event Handling Implementation
- Surveying popular Go libraries and frameworks for messaging.
- Code demonstrations: dispatching and processing events via idiomatic Go patterns.
- Practical session: Developing a basic event-driven service in Go.
Day 3: Messaging Systems & Event Brokers with Go
- Broker Selection & Integration
- Overview of leading brokers: Apache Kafka, RabbitMQ, and NATS.
- Comparing use cases and best practices for Go-centric systems.
- Infrastructure Setup
- Configuring Kafka, RabbitMQ, or NATS using Docker Compose.
- Managing topics, exchanges, queues, and channels.
- Overview of available Go client libraries.
- Practical Workshop
- Developing a sample Go microservice capable of producing and consuming events.
- Integrating the service with the selected event broker.
- Debugging and validating event flow integrity.
Day 4: Deployment, Monitoring, and Advanced Go EDA Topics
- Deployment on Kubernetes
- Containerizing Go applications for production readiness.
- Deploying Kafka (or alternative brokers) on Kubernetes clusters.
- Introduction to KEDA (Kubernetes Event-Driven Autoscaling) for dynamic event consumer scaling.
- Resilience & Observability
- Managing event failures through robust handling strategies.
- Implementing observability standards in Go services.
- Advanced Concepts & Q&A
- Exploring Serverless Event-Driven Architectures using Go.
- Event Choreography vs. Orchestration: Analyzing use cases and design implications.
- Identifying common pitfalls, lessons learned, and industry best practices.
- Open Q&A session with interactive troubleshooting support.
Requirements
- Competence in Go (Golang), with specific experience in utilizing goroutines and channels.
- Foundational knowledge of software architecture patterns, including monolithic and microservice structures.
- Familiarity with Docker and Docker Compose workflows.
- Basic understanding of REST APIs and core networking principles.
- Proficiency with command-line interfaces and Git version control.
- Recommended: Prior exposure to Kubernetes and messaging platforms such as Kafka, RabbitMQ, or NATS.
Intended Audience
- Go developers focused on constructing scalable, event-driven solutions.
- Software engineers transitioning from monolithic or synchronous REST architectures to asynchronous models.
- DevOps and cloud engineers managing containerized or distributed microservice ecosystems.
- Technical architects and system designers investigating EDA patterns within the Go ecosystem.
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.
