TP3381
Event Driven Architecture: Theories, Patterns and Best Practices Training
An event-driven architecture uses events to communicate and coordinate between decoupled services. Applications built using event-driven principles can be highly scalable, resilient, and extensible - essential for large modern applications. These architectures also align with and take advantage of the capabilities of modern cloud providers. This training teaches attendees how to understand and apply event-driven architectures.
Course Details
Duration
3 days
Prerequisites
This course is aimed at solution architects, software engineers, and developers. Students should have a general of application architecture or design. Prior experience with RESTful APIs, messaging, or development using asynchronous/multithreaded applications is useful but not required. The course is technology-neutral and does not assume knowledge of any particular development technology. Workshops are paper exercises and do not involve coding.
Skills Gained
- Understand the relationship between microservices and event-driven architectures
- Work with event types and the event structures that support them
- Manage schema dependency concerns
- Understand streaming services in event-driven architectures
- Solve issues with workflows and long-running transactions
- Manage interactions with other systems
Course Outline
- Introduction to Event-Driven Architectures
- Event-driven thinking and motivation for event-driven architectures
- Characteristics of event-driven architectures and high-level parts
- Benefits, challenges, and use cases
- Relationship between microservices and event-driven architectures
- The Fundamentals of an Event-Driven Architecture
- Foundational definitions
- Event types and the event structures that support them
- Producers, consumers, and server events
- Kinds of event consumers - simple, complex, and streaming.
- Illustration - UberBeats 0.1
- Throughout the course, an example - the hypothetical UberBeats application - is developed to illustrate the concepts discussed and show how each section builds on the previous material in practical terms.
- Workshop 1 - An Event-Driven architecture
- Working in groups, students develop an event-driven architecture. Workshops present a problem and guide students toward a solution while groups have creative freedom to exercise their understanding of the material and develop their solutions. Workshops are taken up as a class so groups see different solutions and learn from each other.
- Event Brokers
- Role of event broker in event-driven architectures
- Queuing and pub/sub
- Overview of Kafka
- Data Schema Management
- Contracts in event-driven architectures
- Explicit and implicit contracts, pros and cons
- Role of a schema in formalizing data format and meaning
- Data representations - JSON, Protocol Buffers, Avro, and CML
- Motivation for schema evolution and strategies
- Principles of event modelling
- Illustration - UberBeats 0.2
- Workshop 2 - Data contracts
- Integration Patterns
- Common integration patterns - change data capture, event sourcing, and Kafka streams
- The CAP theorem and implications for distributed systems
- Good practices to manage consistency concerns
- Managing schema dependency concerns
- Single and multiple consumers, consumer groups, and Kafka Connect.
- Streaming services
- Role of streaming services in event-driven architectures
- Pros, cons, and use cases
- Components to implement a streaming service
- Good practices
- Illustration - UberBeats 0.3
- Microservices
- Definition and characteristics of microservices
- Relationship between microservices and event-driven architectures
- Integration concerns with services not designed for event-driven architectures
- Implementing Event-Driven Workflows
- Definition and characteristics of a workflow
- Challenges with workflows and long-running transactions
- Orchestration patterns
- Role and pros/cons of compensating transactions
- Good practices
- Illustration - UberBeats 0.4
- Event Reprocessing and Deterministic Behaviour
- Event stream concepts, motivation for event reprocessing (what problems does it solve)
- Illustrative use cases
- Requirements - immutability, idempotence
- Managing changes to history (retroactive events)
- Challenges and good practices
- Managing interactions with other systems
- Conclusion
