Get in Touch

Course Outline

Day 1: Foundations of Event-Driven Architecture in Go

  • Introduction to EDA
    • Defining Event-Driven Architecture
    • Comparison of Monolithic, Microservices, and Event-Driven Systems
    • Why Go’s concurrency model and lightweight goroutines are ideal for EDA
  • Core Concepts & Benefits
    • Achieving decoupling, scalability, and resilience in enterprise systems
    • Definitions of Events, Producers, Consumers, and Event Brokers
    • Case studies and real-world examples of Go powering high-performance event systems
  • CAP Theorem & Trade-offs in EDA
    • Overview of Consistency, Availability, and Partition Tolerance
    • The impact of EDA on these core properties
    • Strategies for balancing consistency and availability in Go-based systems

Day 2: Events, Messages, and Communication Patterns in Go

  • Understanding Event Types
    • Distinguishing Domain Events from Integration Events
    • Synchronous versus Asynchronous events in Go applications
  • Messaging Patterns in Practice
    • Implementing Publish-Subscribe (Pub/Sub) in Go
    • Designing and structuring event payloads using JSON, Protocol Buffers, or Avro in Go
  • Implementing Event Handling in Go
    • Overview of leading Go libraries and frameworks for messaging
    • Code demonstrations: dispatching and processing events using idiomatic Go patterns
    • Practical session: Building a basic event-driven service in Go

Day 3: Messaging Systems & Event Brokers with Go

  • Selecting and Integrating Event Brokers
    • Overview of popular brokers: Apache Kafka, RabbitMQ, and NATS
    • Comparing use cases and best practices for Go-based systems
  • Setting Up Messaging Infrastructure
    • Docker Compose configuration for Kafka, RabbitMQ, or NATS
    • Configuring topics, exchanges, queues, and channels
    • Overview of Go client libraries
  • Hands-On Workshop
    • Building a sample Go microservice that produces and consumes events
    • Integrating the service with the selected event broker
    • Debugging and testing 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
    • Introduction to KEDA (Kubernetes Event-Driven Autoscaling) for scaling event consumers
  • Error Handling and Monitoring
    • Addressing event failures using strategic approaches
    • Implementing observability in Go services
  • Advanced Topics & Q&A
    • Exploring Serverless Event-Driven Architectures with Go
    • Event Choreography versus Orchestration: Use cases and design considerations
    • Common pitfalls, lessons learned, and industry best practices
    • Open Q&A session and interactive troubleshooting

Requirements

  • Strong proficiency in Go (Golang), specifically with the use of goroutines and channels
  • A foundational understanding of software architecture models, including monolithic and microservice structures
  • Familiarity with Docker and Docker Compose
  • Basic knowledge of REST APIs and core networking principles
  • Practical experience with command-line interfaces and Git
  • Optional but recommended: prior exposure to Kubernetes and messaging platforms such as Kafka, RabbitMQ, or NATS

Target Audience

  • Go developers focused on building scalable, event-driven applications
  • Software engineers evolving from monolithic or REST-based architectures to asynchronous systems
  • DevOps and cloud engineers managing containerized or distributed microservices
  • Technical architects and system designers investigating EDA patterns with Go
 28 Hours

Testimonials (7)

Upcoming Courses

Related Categories