Course Outline
Day 1: Fundamental Principles of Event-Driven Architecture in Go
- Overview of Event-Driven Architecture
- Definition and operational context of Event-Driven Architecture (EDA)
- Comparative analysis of monolithic, microservices, and event-driven system designs
- Leveraging Go’s concurrency model and lightweight goroutines to optimize EDA implementation
- Core Concepts and Operational Advantages
- Strategies for decoupling, enhancing scalability, and improving resilience in enterprise environments
- Role definitions for events, producers, consumers, and event brokers
- Case studies demonstrating the use of Go in high-performance event systems for government applications
- CAP Theorem Considerations in EDA
- Review of Consistency, Availability, and Partition Tolerance properties
- Analyzing the impact of EDA on data integrity and system availability
- Approaches for balancing consistency and availability in Go-based architectures
Day 2: Event Structures, Messaging, and Communication Patterns in Go
- Classification of Event Types
- Distinguishing between domain events and integration events
- Managing synchronous versus asynchronous event processing in Go applications
- Practical Application of Messaging Patterns
- Implementation of Publish-Subscribe (Pub/Sub) models in Go
- Designing and structuring event payloads using JSON, Protocol Buffers, or Avro
- Event Handling Implementation in Go
- Survey of prevalent Go libraries and frameworks for message management
- Practical examples: dispatching and processing events using idiomatic Go patterns
- Practical exercise: Constructing a basic event-driven service using Go
Day 3: Messaging Systems and Event Brokers Integration with Go
- Selection and Integration of Event Brokers
- Assessment of major brokers: Apache Kafka, RabbitMQ, and NATS
- Comparative analysis of use cases and best practices for Go-based systems for government deployment
- Messaging Infrastructure Configuration
- Establishing environments for Kafka, RabbitMQ, or NATS using Docker Compose
- Configuring topics, exchanges, queues, and communication channels
- Overview of Go client library capabilities
- Practical Workshop
- Development of a Go microservice capable of producing and consuming events
- Integration of the service with the selected event broker
- Techniques for debugging and validating event flows
Day 4: Deployment, Monitoring, and Advanced EDA Topics in Go
- Deployment of Go Event-Driven Applications on Kubernetes
- Containerization of Go applications for production readiness
- Deployment of Kafka (or alternative brokers) on Kubernetes clusters
- Application of KEDA (Kubernetes Event-Driven Autoscaling) to manage event consumer scaling
- Error Management and System Monitoring
- Strategies for handling event failures and ensuring reliability
- Implementing observability standards in Go services for government compliance
- Advanced Concepts and Consultation
- Examination of Serverless Event-Driven Architectures using Go
- Comparison of Event Choreography and Orchestration: Operational use cases and design implications
- Identification of common pitfalls, operational lessons, and industry best practices
- Open forum for questions and collaborative troubleshooting
Requirements
- Demonstrated proficiency in Go (Golang), specifically in the application of goroutines and channels
- Foundational understanding of software architecture models, including monoliths and microservices
- Familiarity with Docker and Docker Compose operational workflows
- Basic knowledge of REST APIs and core networking concepts
- Experience with command-line interfaces and Git version control systems
- Recommended but not mandatory: Prior exposure to Kubernetes and messaging systems such as Kafka, RabbitMQ, or NATS
Target Audience
- Go developers focused on building scalable, event-driven applications for government systems
- Software engineers transitioning from monolithic or REST-based architectures to asynchronous system designs
- DevOps and cloud engineers managing containerized or distributed microservices
- Technical architects and system designers evaluating EDA patterns for implementation in Go
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.
