Course Overview
This four-day online corporate training is for Azure developers and software architects who design and build event-driven distributed applications on .NET 10. It starts where AI-200 (formerly AZ-204) stops. The exam names the building blocks, this class implements the patterns on top of them, from the transactional outbox and idempotent consumers to event sourcing, durable workflows and sagas.
Every topic is taught on one domain, Grey Logistics, a last-mile parcel delivery company. Shipments are booked, vans report their position, scanners report every parcel, and an operations console shows the network live.
Day one designs the system with event storming, commands, events and reliability patterns, models it with Aspire and hosts it on Container Apps and AKS. Day two connects the services with Service Bus, Event Grid and Event Hubs. Day three stores the history in Cosmos DB with outbox, change feed projections, CQRS and event versioning, then makes the services portable with Dapr.
Day four makes long-running processes survive failures with the Durable Task Scheduler, Durable Functions, Dapr Workflow and saga orchestration. It finishes with AI agents that take part in the event flow like any other service.
Course Content
Module 1: Designing Event-Driven Distributed Systems
- Modular Monolith vs. Microservices
- Sync vs. Async: Commands & Events
- Event Storming: Find Service Boundaries
- Event Types: Domain, Integration, CloudEvents
- Reliability Patterns: Outbox, Saga, Idempotency
- Azure Messaging: Pick the Broker
Module 2: Building Distributed Apps with Aspire
- Aspire AppHost: Model the System
- ServiceDefaults: Telemetry, Resilience, Discovery
- Aspire Integrations: Hosting & Client
- Aspire Dashboard: Traces Across Services
- Polyglot AppHost: Angular & Python
- Aspire Testing: Distributed Integration Tests
Module 3: Hosting on Container Apps & AKS
- Aspire Deploy: ACR & Container Apps
- Key Vault & App Configuration
- Revisions: Traffic Splitting & Draining
- AKS: Aspire-Generated Kubernetes Manifests
- Application Insights: Traces & KQL
Module 4: Reliable Messaging with Service Bus
- Topic Subscriptions: SQL Filters
- Azure Functions: Service Bus Triggers
- Competing Consumers: KEDA Scale Rules
- Sessions: Ordered Message Processing
- Dead-Letter Queues: Poison Messages
- Idempotent Consumers: Duplicate Detection
Module 5: Events & Streams with Event Grid & Event Hubs
- Event Grid: Custom Topics & Subscriptions
- Event Grid: Filters, Retries, Dead-Letter
- Event Grid Namespaces: Pull Delivery
- Event Hubs: Partitions & Checkpoints
- Event Hubs: Kafka-Compatible Streaming
- SignalR Service: Push to Browsers
Module 6: Event Sourcing & CQRS with Cosmos DB
- Transactional Outbox: Atomic Publishing
- Change Feed Processor: Projections
- CQRS: Separate Writes from Reads
- Read Models: Indexing, RUs, Consistency
- Managed Redis: Change-Feed Cache Invalidation
- Event Store: Aggregates & Snapshots
- Event Versioning: Evolve Schemas Safely
Module 7: Dapr Building Blocks for Portable Services
- Dapr Sidecar: Run with Aspire
- Service Invocation: mTLS & Retries
- State Stores: ETags & Concurrency
- Pub/Sub: Swap Brokers via Components
- Resiliency Policies: Retries & Breakers
- Dapr Actors: Virtual Actor Model
- Managed Dapr: Container Apps vs. AKS
Module 8: Durable Execution, Workflows & Sagas
- Durable Execution: Replay & Determinism
- Durable Task Scheduler: Managed Backend
- Durable Functions: Orchestrations & Entities
- Durable Timers: External Events & Approvals
- Durable Task SDK: KEDA-Scaled Workers
- Dapr Workflow: Portable Orchestrations
- Saga Orchestration: Compensating Activities
Module 9: AI Agents in Event-Driven Systems
- Microsoft.Extensions.AI: Foundry Model Client
- Agent Subscribers: React to Events
- LLM Calls: Durable Activities
- Rate Limits: Priority Queues & KEDA
- Vector Search: Change Feed Embeddings
- Agent Choreography: Events vs. A2A
Find out more in our course video
Who should attend
- Azure developers who build distributed and event-driven applications
- Software architects who design microservices on Azure
Prerequisites
- C# and .NET experience
- Azure development at AI-200 (formerly AZ-204) level
- Docker Desktop
- An Azure subscription
- A GitHub account
Outline: Master Class: Designing and Implementing Cloud Native Applications using Microsoft Azure (DICNMA)
Introduction to Cloud Native Applications & Cloud Maturity Model
- What are Cloud Native Applications
- Cloud Maturity Model: Monolith vs Microservices Architecture
- Clean Architecture
- Introduction to .NET Aspire: Orchestration, Components, Tooling
- Microservices Communication Patterns
- Architecture Overview of the Sample App & Services
- Cloud Architecture Design Patterns
- Container Hosting & DevOps
- Provisioning of Azure Resources using Azure CLI & Bicep
- Introduction to Azure Cost Management
Container Essentials & Configuration Management
- Docker Development Workflow: Multistage Build, Run & Debug Recap
- Container builds using Azure Container Registry
- Using docker-compose.yaml to run multiple containers for local development
- Kubernetes Developer Essentials
- Container Configuration Management (Env Variables, Key Vault & Azure App Config Service)
- Understanding the Sidecar Pattern
- Optimizing .NET 8 Container Size using chiseled, trim and aot
- Container Security Patching
Developing & Publishing Microservices using Azure Container Apps (ACA)
- Azure Container Apps Introduction
- Azure Container Apps vs Kubernetes
- Publish Microservices (Ingress, Egress) and manage Revisions
- Secrets, Managed Identities & Service Connectors
- Using Azure App Configuration in Azure Container Apps
- Task Automation using Jobs
- Scaling & KEDA (Kubernetes Event Driven Auto-Scaling)
- Stateful Apps using Volume Mounts & Persistent Storage
- Microsoft Entra ID Easy Authentication
- Health Probes, Monitoring, Logging & Observability
Stateful Microservices using Azure Functions
- OData, Open API Support and Dependency Injection
- Hosting: Serverless vs Containers
- Environment Variables, Key Vault, and App Configuration
- Using Managed Identities and Service Connector to access Azure Resources
- Implementing and monitoring Durable Functions to implement long running processes
- Azure Durable Entities, Aggregation & Virtual Actors
- Publishing Azure Functions to Azure Container Apps
NoSQL Data & Event storage using Cosmos DB
- From Relational to NoSQL: Do's and Don’ts
- Partitioning Strategies & Performance Optimization
- Domain Driven Design (DDD) Basics & Bounded Context Pattern
- Using SDKs to interact with Cosmos DB
- Using Data Api Builder to expose Cosmos DB
- Implementing an Event Store using Event Sourcing
- Creating Materialized Views using Materialized Views Builder
- Optimizing Read/Write Performance with Change Feed & CQRS
Designing and Implementing Message- & Event Driven Apps
- Introduction to Messaging
- Message Types and Channels
- Introduction to Event Driven Architecture (EDA)
- Event Types: Domain-, Integration-, Cloud Events
- Publishing & Subscribing Events using an Event Bus
- Distributed Transactions
- Saga: Orchestration, Choreography
- Common Message Brokers in Azure
Using Distributed Application Runtime - Dapr
- Introduction to Dapr
- Understanding Dapr Architecture & Building Blocks
- Developer Environment Setup, Debugging & State Management
- Using Dapr Components in Azure Container Apps
- Service Invocation & Bindings
- Pub/Sub Messaging
- Secrets and Configuration
- Azure Functions & Dapr Bindings
- Dapr Actors & Saga
- Observability and Distributed Tracing
Optimizing and Securing Access using Api Management & Application Gateway
- API Management (APIM) Recap
- API Versions and Revisions using Azure Container Apps
- Authenticating to Backend Services
- Understanding Gateway Pattern and Backends for Frontend Pattern (BFF)
- Implement BFF using APIM and GraphQL
Connecting Real Time Micro Frontends using Event Grid
- Micro Frontends: Introduction & Benefits
- Publish the Shop Micro Frontend to Azure Container Apps
- Real-time connected Micro Frontend using Azure Event Grid and SignalR
- Connect the Real Time Kitchen Dashboard
- Connect the Order Status Micro Frontend