Event-Driven Architecture with Go Training Course

Day 1: Foundations of Event-Driven Architecture in Go

• Introduction to EDA
  • Defining Event-Driven Architecture.
  • Comparing Monolithic, Microservices, and Event-Driven systems.
  • Why Go’s concurrency model and lightweight goroutines are well-suited for EDA.
• Core Concepts & Benefits
  • Achieving decoupling, scalability, and resilience in enterprise settings.
  • Defining Events, Producers, Consumers, and Event Brokers.
  • Real-world examples and case studies of Go powering high-performance event systems.
• CAP Theorem & Trade-offs in EDA
  • Overview of Consistency, Availability, and Partition Tolerance.
  • How EDA impacts these system properties.
  • Strategies 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.
  • Synchronous versus Asynchronous events in Go applications.
• Messaging Patterns in Practice
  • Implementing Publish-Subscribe (Pub/Sub) patterns in Go.
  • Designing and structuring event payloads using JSON, Protocol Buffers, or Avro within Go.
• Implementing Event Handling in Go
  • Review of popular Go libraries and frameworks for messaging.
  • Code examples: Dispatching and processing events using idiomatic Go patterns.
  • Hands-on session: Constructing a basic event-driven service in Go.

Day 3: Messaging Systems & Event Brokers with Go

• Selecting and Integrating Event Brokers
  • Overview of key brokers: Apache Kafka, RabbitMQ, and NATS.
  • Comparing use cases and best practices for Go-based systems.
• Setting Up Messaging Infrastructure
  • Configuring Kafka, RabbitMQ, or NATS using Docker Compose.
  • Setting up topics, exchanges, queues, and channels.
  • Overview of Go client libraries.
• Hands-On Workshop
  • Building a sample Go microservice capable of producing and consuming events.
  • Integrating the service with the selected event broker.
  • Debugging and testing event workflows.

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.
  • Introduction to KEDA (Kubernetes Event-Driven Autoscaling) for scaling event consumers.
• Error Handling and Monitoring
  • Strategies for handling event failures effectively.
  • Implementing observability practices 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.