Course Outline
Day 1: Establishing the Fundamentals of Event-Driven Architecture in Go
- Introduction to EDA Principles
- Defining Event-Driven Architecture and its operational role
- Evaluating Monolithic, Microservices, and Event-Driven paradigms for government applications
- Leveraging Go’s concurrency model and lightweight goroutines to support scalable event-driven systems
- Core Concepts & Strategic Benefits
- Enhancing system decoupling, scalability, and resilience within enterprise environments
- Identifying key components: Events, Producers, Consumers, and Event Brokers
- Analyzing real-world implementations where Go facilitates high-performance event processing for government agencies
- CAP Theorem & Architectural Trade-offs in EDA
- Understanding Consistency, Availability, and Partition Tolerance requirements
- Assessing the impact of EDA on these distributed system properties
- Developing strategies to balance consistency and availability in Go-based solutions for government use cases
Day 2: Event Management, Messaging Protocols, and Communication Patterns in Go
- Categorizing Event Types
- Distinguishing between Domain Events and Integration Events
- Evaluating Synchronous versus Asynchronous event processing within Go applications
- Practical Messaging Patterns
- Implementing Publish-Subscribe (Pub/Sub) architectures in Go
- Structuring efficient event payloads using JSON, Protocol Buffers, or Avro in Go
- Executing Event Handling in Go
- Surveying established Go libraries and frameworks for messaging tasks
- Demonstrating idiomatic Go patterns for dispatching and processing events with code examples
- Practical exercise: Constructing a foundational event-driven service in Go tailored for government operations
Day 3: Configuring Messaging Systems & Event Brokers with Go
- Selecting and Integrating Event Brokers
- Reviewing leading brokers including Apache Kafka, RabbitMQ, and NATS
- Evaluating use cases and best practices for integrating these brokers into Go-based government systems
- Infrastructure Configuration
- Utilizing Docker Compose to deploy Kafka, RabbitMQ, or NATS environments
- Configuring topics, exchanges, queues, and channels for secure event routing
- Overview of compatible Go client libraries for broker interaction
- Hands-On Workshop
- Developing a sample Go microservice to produce and consume events
- Integrating the service with selected event broker infrastructure
- Conducting debugging and validation of event flows for reliability assurance
Day 4: Deployment, Monitoring, and Advanced EDA Topics in Go
- Deploying Go Event-Driven Applications on Kubernetes
- Containerizing Go applications for production-grade government deployments
- Orchestrating Kafka (or alternative brokers) within Kubernetes clusters
- Introducing KEDA (Kubernetes Event-Driven Autoscaling) to manage scaling of event consumers effectively
- Error Management & System Observability
- Implementing robust strategies for handling event failures and ensuring data integrity
- Establishing comprehensive observability frameworks for Go services supporting government missions
- Advanced Considerations & Collaborative Review
- Exploring Serverless Event-Driven Architectures utilizing Go for flexible government solutions
- Comparing Event Choreography versus Orchestration: Design implications and appropriate use cases
- Reviewing common challenges, lessons learned, and established best practices
- Conducting open Q&A session and interactive troubleshooting for practical implementation guidance
Requirements
- Demonstrated proficiency in Go (Golang), including the implementation of goroutines and channels for concurrent processing
- Foundational understanding of software architecture paradigms, such as monolithic and microservice models
- Familiarity with Docker and Docker Compose for containerization
- Basic knowledge of RESTful APIs and networking principles
- Hands-on experience utilizing command-line interfaces and Git version control systems
- Optional but beneficial: previous exposure to Kubernetes and messaging platforms such as Kafka, RabbitMQ, or NATS
Audience
- Go developers tasked with building scalable, event-driven applications for government systems
- Software engineers transitioning from monolithic or REST-based architectures to asynchronous event-driven frameworks
- DevOps and cloud engineers managing containerized or distributed microservices within federal infrastructure
- Technical architects and system designers evaluating Event-Driven Architecture (EDA) patterns using Go for public sector solutions
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.
