20-22 OCT 2022

Distributed Tracing has been around for a while, but was always quite niche, reserved for the Netflix and Amazon's of the world. With your company likely looking more at Microservices as a path forward to scale and modernisation, you will almost certainly start to think about debugging and monitoring this in production. Luckily, there's a new(ish) project that is here to help, and provide familiar hooks into your applications to get the vital information you need to have confidence in your production environment. We'll walk through what distributed tracing is, how it relates to Observability (o11y), and then run through some examples of how to get started with it in your .NET Core applications. Finally, we'll demo a few different backends for storing and visualizing the data, Jaegar (OpenSource) and Honeycomb.io (Hosted)

What do you need to build a serverless application that can communicate with client devices in realtime? In this session I'll show how to combine Azure Functions, Durable Functions and serverless WebSockets (Ably) to achieve this. The context is a multi-player ADnD style game (with pixel-art of course) running on Azure Static Web Apps. I'll cover: - How the clients interact with HTTP triggered functions in the .NET based Azure Functions back-end. - How Durable Entities are used for the centralized game state. - How serverless WebSockets are used to sync the state to the clients. We will play the game live as well! https://quest.ably.dev/

Build and release configuration as code has become the de facto way for most continuous build and release solutions on the market today. Most commonly this manifests itself through a custom task-based domain-specific language using YAML or JSON files. But wouldn't it be nice if you instead of using a markup language, could use a proper programming language, with already well-defined and documented control structures, flow statements like for, white, do, etc. This session will step by step go through how you using C# can orchestrate your GitHub Actions build and release pipelines. A pipeline that you can test and debug not only by tedious push and wait for CI to fail/succeed, but also locally using standard developer tools like VS Code with full fidelity inspecting variables, breakpoints, etc. reusing the language skill your team already has, reducing friction and unnecessary context switching. All this made possible using the open-source build orchestration tool Cake.

Have you considered using an actor model to build an event based CQRS system? Why not? Actors and DDD are a match made in heaven! When developers learn about DDD, they tend to find a way to work the principles into their codebase. After a while, they may end up with some form of event sourcing or CQRS. But often times, the possibilities of using an actor model, such as Akka.NET, are overlooked. In this talk I will show you to all the things you need to know if you want to build such a system using .NET 6 and Akka.NET. Expect to see a lot of code! An elementary knowledge of DDD principles is required to attend this session.

So you built your own web app in Blazor WASM. Deployed using Azure Static Web Apps, even added some dynamic content with an Azure Function or two.

But what about making sure that you are you?

Azure Static Web Apps provide simple integration to GitHub, Facebook and Twitter to provide authentication without having to store passwords yourself!

We'll add authentication, look at how to fit this into the developer inner loop with the Static Web App CLI and how to pass the authentication through to your Azure Function!

Finally, we'll look at the flexibility a Standard Tier app provides by swapping out the simple authentication for a custom authentication!