Building cloud-ready, resilient systems in .NET

You may think that your application is already cloud-ready, it's deployed in the cloud isn't it?!

But in truth, if your application is hard to monitor/scale/release/maintain, lacks resiliency, and is poorly structured, then it's not "cloud-ready". So what does "cloud-ready" actually mean?

A “cloud ready” application is a legacy software application that has been modified to run on cloud computing infrastructure.  Whether you are looking at a modular monolith or a full-blown distributed system, building a cloud-ready, resilient application is a must.

 In this workshop, we will look at the requirements for Tacky Tacos. A fictional taco business that's thriving and wishes to expand. We'll look at all the different requirements that need to be met, starting with a code kata and how we can apply various design patterns to our way of thinking. We'll then move on to actually building out a functioning, all-be-it, contrived application in .NET 7 and C#, learning as we go.

 Topics we'll cover:

Architecture and Methodology

  • Modular monolith vs microservices vs SOA

  • The "12 Factors" and what they are

  • Distribution and Modularisation

  • Common design patterns

  • Modelling requirements

  • Practical: Code kata for tacky tacos 


  • .NET 7 application development recap

    • Dependency Injection

    • HttpClientFactory

    • Good practices

  • External Configuration

    • What it is and why it is useful

    • Practical: implement external configuration with 

  • Databases

    • Why separate DBs may be required

    • Eventual Consistency

    • DB options - SQL, Document, Table, Blob, Serverless 

    • Practical: Create two distinct databases - later these will employ "eventual consistency"

  • Synchronous communication

    • Introduction to synchronous communication and when to use it

    • Synchronous options

    • Practical: build an HTTP endpoint for a web client

    • Practical: implement gRPC to communicate with a non .NET application

    • Practical: implement a hub with SignalR to broadcast real-time information

  • Asynchronous communication

    • Introduction to asynchronous communication and when to use it

    • Message brokers

    • Implementation considerations

    • Error handling

    • Choosing a message broker

    • Practical: Implement a pub/sub with RabbitMQ 

  • API gateways and BFF

    • Introduction to the use cases and considerations

    • When to use BFF

    • Practical: API Gateway with YARP

  • Load balancing

    • What it is and why we need it

    • Practical: Add load balancing to YARP

  • Service discovery

    • What it is and why we need it

    • Practical: set up Service Discovery using Steeltoe and Eureka

    • Practical: Integrate Service Discovery with YARP API gateway

  • Resiliency 

    • What makes an application resilient?

    • policies, circuit breakers, fallbacks and retries

    • Practical: implement policies with Polly

  • M2M Authentication

    • Why it's needed

    • Practical: Implement M2M authorization with Auth0

  • Monitoring, tracing, observability

    • What is it and why do we need it

    • What is the OpenTelemetry project

    • What tools are available

    • Practical: Implement various endpoints and actuators with Steeltoe

  • Serverless

    • When to use a serverless function and why

    • Practical: create an Azure Function service


Equipment and software

  • A computer - either Windows PC or macOS (I have no experience with Linux so if you bring a Linux machine my problem-solving will be limited)

  • Visual Studio 2022 or JetBrains Rider or VS Code

  • .NET 7

  • Docker Desktop


Layla Porter

Date & time 20-21 APR 2023, 9:30-17:30 Places Available 20
Registration Closed