Web API 300

Overview

This course is meant for advanced C# Developers tasked with designing and creating HTTP-Based APIs in support of the business and technical requirements of your company.

It provides some "big picture" coverage of buzzwords like "Event-Driven Architecture", "Event Streaming", "Asynchronous Messaging", "Event Sourcing", and "CQRS".

Primarily, this course is designed to supplement the earlier courses and fill in the gaps on the promise of "independently deployable services".

Format

This four-day course will prepare developers to HTTP-based APIs using Microsoft's .NET Platform (Currently .NET 9).

The class will include periods of lecture, "Code With Me", and short practice exercises. In addition, two multi-hour labs will be included to help developers integrate the concepts from the class.

Dedicated time will be allocated daily for questions and one-on-one code reviews.

Prerequisites

This course will emphasize (but not be limited to) developer testing of HTTP based APIs created with .NET. Developers should consider taking Web API 200 first.

Objectives

This is an advanced course for developers that contribute to the design and architecture of a Service Oriented Application implementation using .NET.

The Goal of Independent Deployability Fulfilled

In the previous classes, we covered patterns that will lead your team and project to the goal of "independent deployability". Briefly, this means that you and your team can take advantage of techniques like Continuous Integration and Continuous Deployment (or Delivery) to be responsive to the business needs of your service.

We will review and extend the patterns from previous classes to help us reach this goal.

• Designing APIs for Quick Pipeline Throughput and Optimal Developer Feedback
• Resiliency Patterns for Integrations
• How to Move To Practices and Patterns that Don't Require Services To Share Databases

Reducing Coupling from Backing Services

• Understand and Implement Event Streaming (Kafka, Amazon SNS, Azure Service Bus, etc.) For Resilient Integration
• The Limits of Transactional Consistency Outside of Service Boundaries
• Understand Eventual Consistency Patterns
• Designing Intra-Service Messages For Integration
• Securing Intra-Service Messaging
• Messaging Delivery Patterns (Exactly Once, At Least Once, etc.)
• Idempotent Message Handling and Design
• "Dead Letters", "Outboxes", "Inboxes", and other Resiliency Patterns
• Validating Messages from a Message Broker
• Using a Transformer/Adapter To Lessen Coupling (Anti-Corruption Layer)

Service Design Patterns For Maximum Velocity

• Using "Event-Driven Architecture" Inside Your Service
• Event Sourcing (vs. Event Streaming)
• Designing Events, Commands, and Read Models (Command/Query Responsibility Separation (CQRS))
• Implementing Policies For Commands
• Command Processing: Decider Pattern
• Creating Read Model Projections and Exposing Them From Your API

Developer Testing

• Testing Integration Scenarios with Event Streaming

Expected Outcome of this Training

At the conclusion of the Web API 300 Course, developers will be able to:

• Implement Independently Deployable Services
• Integrate Feedback from Testing, the Pipeline, and OTEL Data to Improve the Reliability and Performance of a Service
• Understand Event Streaming, Message Queues, and Other Distributed Messaging Patterns
• Understand and Implement Event Sourcing in an API Project
• Create Read Models using Projections, Snapshots and "Live" Event Stream Queries
• Explore "streaming" events to other services and UI clients using message brokers, and Server Sent Events and WebSockets
• Understand the Infrastructure Requirements for Distributed Applications