Event-Driven Architecture with Go Training Course

Day 1: Fundamentals of Event-Driven Architecture 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 ideally suited for EDA.
• Core Concepts and Advantages
  • Understanding decoupling, scalability, and resilience in enterprise environments.
  • Defining key roles: Events, Producers, Consumers, and Event Brokers.
  • Examining real-world case studies where Go drives high-performance event systems.
• CAP Theorem and EDA Trade-offs
  • Overview of Consistency, Availability, and Partition Tolerance.
  • How EDA impacts these architectural properties.
  • Strategies for balancing consistency and availability in Go-based systems.

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.
• Practical Messaging Patterns
  • Implementing Publish-Subscribe (Pub/Sub) in Go.
  • Designing event payloads using JSON, Protocol Buffers, or Avro within Go applications.
• Implementing Event Handling in Go
  • Survey of popular Go libraries and frameworks for messaging.
  • Code demonstrations: dispatching and processing events via idiomatic Go patterns.
  • Practical session: Constructing a basic event-driven service in Go.

Day 3: Messaging Systems and Event Brokers with Go

• Selecting and Integrating Event Brokers
  • Overview of leading brokers: Apache Kafka, RabbitMQ, and NATS.
  • Comparing use cases and best practices for Go-based systems.
• Establishing Messaging Infrastructure
  • Configuring Docker Compose for Kafka, RabbitMQ, or NATS.
  • Setting up topics, exchanges, queues, and channels.
  • Review of Go client libraries.
• Practical Workshop
  • Developing a Go microservice capable of producing and consuming events.
  • Connecting the service to the selected event broker.
  • Techniques for debugging and testing event flows.

Day 4: Deployment, Monitoring, and Advanced Topics in Go EDA

• Deploying Go Event-Driven Applications on Kubernetes
  • Preparing Go applications for production via containerization.
  • Deploying Kafka (or alternative brokers) on Kubernetes clusters.
  • Introduction to KEDA (Kubernetes Event-Driven Autoscaling) for consumer scaling.
• Error Handling and Monitoring
  • Managing event failures using robust strategies.
  • Implementing observability within Go services.
• Advanced Topics and Q&A
  • Investigating Serverless Event-Driven Architectures with Go.
  • Event Choreography vs. Orchestration: Analyzing use cases and design implications.
  • Identifying common pitfalls, learning from lessons, and applying best practices.
  • Open Q&A session for interactive troubleshooting.