Event-Driven Systems at the Edge

Streams, Queues and Distributed State

Introduction

1. What You Will Learn
2. The Reference Application: EdgeFleet
3. Technology Stack
4. How to Use This Book
5. What This Book Does Not Cover

Chapter 1: Why Event-Driven? The Promise and the Peril

1. The Connected World at Scale
2. From Monolith to Events
3. The Cost of Getting It Wrong
4. What This Book Will Build
5. How to Read This Book

Chapter 2: Event-Driven Architecture Foundations

1. Events, Messages and Commands
2. The Producer-Consumer Model
3. Point-to-Point Versus Publish-Subscribe
4. Coupling, Cohesion and Autonomy
5. Anti-Patterns and Common Mistakes

Chapter 3: Message Brokers, Queues and Streams

1. Queues: Load Leveling and Work Distribution
2. Topic-Based Pub/Sub: Broadcasting and Filtering
3. Event Streams: Ordered, Persistent, Replayable
4. Broker Architectures: From RabbitMQ to Kafka to NATS
5. Choosing a Messaging Primitive

Chapter 4: Kafka Internals and Architecture

1. Topics, Partitions and Offsets
2. The Broker and Controller
3. Replication and ISR
4. Producer Semantics and Batched Writes
5. Consumer Groups and Offset Management
6. Log Compaction and Retention
7. Summary

Chapter 5: NATS, Pulsar and Cloud-Native Alternatives

1. NATS and JetStream: Simplicity and Speed
2. Apache Pulsar: Multi-Tenant Cloud Scale
3. Managed Cloud Services: Kinesis, Pub/Sub, Event Hubs
4. Brokerless and Mesh Architectures
5. Platform Selection Matrix
6. Summary

Chapter 6: Events, Schemas and Serialization

1. Designing Domain Events
2. Serialization Formats: JSON, Protobuf, Avro
3. Schema Registry and Evolution Rules
4. Backward and Forward Compatibility
5. Summary

Chapter 7: Producers - Publishing Events Reliably

1. Producer Design Patterns
2. Kafka Producer Configuration
3. Idempotent Producers
4. Ordering Guarantees and Key-Based Routing
5. Reference application: EdgeFleet producers
6. Error Handling and Retries
7. Summary

Chapter 8: Consumers - Processing Events Correctly

1. Consumer Group Dynamics
2. At-Least-Once and At-Most-Once Consumption
3. Idempotent Consumers and Deduplication
4. Backpressure and Graceful Degradation
5. Reference Application: EdgeFleet Consumers
6. Summary

Chapter 9: Stream Processing - Transformations and Joins

1. Map, Filter and Aggregate
2. Tumbling, Sliding and Session Windows
3. Stream-Stream and Stream-Table Joins
4. Stateful Processing and Checkpoints
5. Reference Application: The Stream Processor

Chapter 10: Kafka Streams and Flink

1. Kafka Streams: Embedded and Lightweight
2. Apache Flink: Batch-and-Stream Unified
3. State Stores and RocksDB
4. Fault Tolerance and Recovery
5. When to Use Which
6. Summary

Chapter 11: Event Sourcing and CQRS

1. Command Query Responsibility Segregation
2. Event Sourcing: Appending the Truth
3. Sagas and Distributed Transactions
4. Read Models and Projections
5. Reference Application: Event-Sourced Domain

Chapter 12: Distributed State Management

1. Stateful Services in a Stateless World
2. Distributed Caches and KV Stores
3. Eventual Consistency and Conflict Resolution
4. Partitioning State and Hot Keys
5. Reference Application: Distributed State Store
6. Summary

Chapter 13: Edge Computing Fundamentals

1. Cloud, Fog and Edge: A Continuum
2. Latency, Bandwidth and Autonomy
3. Edge Runtimes: Containers, Functions and WASM
4. Edge Deployment Models
5. Reference Application: The Edge Topology
6. Summary

Chapter 14: Serverless Event Processing

1. Serverless Execution Models
2. Cloud Functions: AWS Lambda, Cloudflare Workers, Azure Functions
3. Edge Functions and CDNs
4. Cold Starts, Limits and Workarounds
5. Reference Application: Serverless Handlers
6. Wrapping up

Chapter 15: Cloud-to-Edge Communication

1. Edge-to-Cloud Patterns
2. Store-and-Forward for Intermittent Connectivity
3. Delta Sync and Operational Transformations
4. Bi-Directional Event Routing
5. Reference Application: Edge-to-Cloud Pipeline
6. Summary

Chapter 16: Delivery Guarantees, Deep Dive

1. At-Most-Once, At-Least-Once, Exactly-Once
2. The Two-Phase Commit Problem
3. Transactional Outbox Pattern
4. Idempotent Operations: Making At-Least-Once Safe
5. Reference Application: Transactional Messaging
6. Summary

Chapter 17: Consistency, Ordering and Partitioning

1. CAP and the PACELC Theorem
2. Linearizability Versus Sequential Consistency
3. Partition Key Design and Hot Spots
4. Compensating for Disordered Events
5. Reference Application: Consistency Choices
6. Summary

Chapter 18: Fault Tolerance and Recovery

1. Failure Modes in Distributed Systems
2. Retries, Dead Letter Queues and Alerting
3. Circuit Breakers and Bulkheads
4. Leader Election and Raft
5. Reference Application: Failure Handling
6. Summary

Chapter 19: Observability and Operations

1. Logging: Structure, Correlation and Volume
2. Metrics: Red Signals and SLOs
3. Distributed Tracing End to End
4. Capacity Planning and Cost Control
5. Reference Application: Observability Stack
6. Summary

Chapter 20: Security, Secrets and Multi-Tenancy

1. Authentication and Authorization Models
2. TLS, mTLS and Encryption at Rest
3. Secret Management Patterns
4. Multi-Tenant Isolation and Quotas
5. Reference Application: Security Layer
6. Summary

Chapter 21: CI/CD, IaC and Deployment Automation

1. Infrastructure as Code with Terraform
2. Containerization and Kubernetes
3. GitOps and Progressive Delivery
4. Schema and Migration Pipelines
5. Reference Application: Complete Deployment
6. Summary

Chapter 22: Production Hardening and the Full System

1. The Complete Reference Architecture
2. Load Testing and Performance Validation
3. Runbooks and On-Call
4. Migrating from Monolith to Event-Driven
5. What Comes Next

Conclusion

References