Alex Thissen
Cloud buster
Hedel, The Netherlands
Alex is an application development enthusiast since the late nineties and works as an architect, lead developer and mentor at large enterprises and small companies. He spends his time teaching other developers the details of the Microsoft development platform and frameworks, and coaches architects to design and build modern distributed applications at cloud scale. He has received the Microsoft Most Valuable Professional award for Visual Studio and Development Technologies since 2007. In his spare time Alex likes to participate in all kinds of sport, and loves playing and programming new and retro video games.
Links
Awards
Area of Expertise
Topics
Building cloud-native microservices with Dapr
Modern distributed applications require much more than just application logic. Features such as state management for services, communication using publish/subscribe messaging and event-driven binding to cloud resources might be needed. Dapr introduces a runtime to offer such building blocks, and is less invasive in your application, allowing you to pick and choose what you need. In this workshop, we will look at the approach that the Dapr runtime takes with a sidecar architecture, separating application logic from the Dapr runtime components. You learn to develop distributed applications in .NET using Dapr's features and, how to bind to messaging infrastructure and cloud resources.
Dapr on GitHub Codespaces workshop
Dapr is an open source, event-driven, portable runtime for building microservices. It provides powerful building blocks to make it easy for developers to build resilient microservice applications using a variety of languages and frameworks.
In this workshop you will get an introduction of Dapr and the Dapr building blocks. After that, you will learn how to apply Dapr yourself in a sample application during the hands-on part of the workshop.
The workshop features step-by-step instructions. During the workshop you will get hands-on experience with the following Dapr building blocks: service invocation, state management, pub/sub, bindings and secret management. You will also learn how to deploy Dapr to a Kubernetes (AKS) cluster and how to use Dapr to leverage several Azure services.
DevContainers: Development environments as code
Are you struggling to maintain your development environment setup? Does it take long? If so, come check out devcontainers: full-featured development containers for your dev environment. Get started with a new machine, codebase or project in minutes, not days. Clean up in seconds.
In this session you will learn what devcontainers are, how they work and how to use and create them using clients such as the devcontainer CLI, Visual Studio Code and Rider or CodeSpaces.
We will also cover the specification and how to make them reusable by packaging and publishing devcontainers as templates and features.
Devcontainers are essential to a great developer experience and in this session you learn why and how.
Doing Kubernetes DevOps style with Codespaces
This training introduces you to Docker and container technology for DevOps teams. We will show you how to apply DevOps practices to cloud-based container solutions, complete with hands-on exercises using Kubernetes. The training uses Microsoft tooling and technology, but you can apply the skills you will learn in any technology stack.
This workshop contains hands-on labs to help you gain practical experience with the following topics:
- Getting started with containers and Docker
- Working with Kubernetes
- Canary releases and A/B testing using Istio service mesh
- Becoming familiar with GitHub Codespaces during the Labs
Objectives:
- Get hands-on experience supporting DevOps practices with available tools.
- Understand the implications for DevOps teams to build, deploy and run container-based solutions in a cloud environment.
- Practice finding and fixing bugs without downtime.
Target audience:
This training is intended for developers and architects that want to learn about DevOps practices and tooling for a cloud-based Kubernetes solution.
This workshop is divided into two parts with separate labs and allows you to start at any point given your experience. The first part introduces you to container technology and tooling with .NET and ASP.NET Core. The second part covers container clusters and service meshes using Kubernetes and Istio. Throughout the workshop you will gradually improve your DevOps skills for container based solutions.
All courseware is on GitHub, so you can both prepare for the workshop ahead of time and finish the workshop from home if you are unable to finish the labs during the workshop.
Labs can be executed your laptop, but we prefer using GitHub Codespaces. When using Codespaces, you will only need to bring a modern browser in order to perform the labs. We will provide you with proper access during the workshop.
Evolving your service landscape
Even now that applications are becoming more distributed and decoupled, you still need to make sure you do not break contracts between the various moving parts of your solutions as your landscape grows and matures.
In this session we will have a look at how you can do versioning of contracts between clients and services, as well as between publishers and subscribers. Also, you are going to see what client contract testing is all about and how it can help you to get a grip on releasing new versions of your services.
We will look at the concepts, approaches and strategies, but also get a practical view of applying these ideas into your software lifecycle using .NET based solutions and Pact for contract testing.
Go (con)figure - making sense of the .NET configuration system
By properly configuring your applications you can make them behave in a flexible manner in different environments. This is an essential enabler to do proper CI/CD while adopting a DevOps way of working. .NET offers a hierarchical configuration system able to layer and structure multiple configuration value providers and dealing with changes during operations. Understanding the specifics of this system will allow you to get the most out of configuring your cloud-based solutions. In this session we will look at the details of the configuration system of .NET Core and beyond and how to incorporate it in various scenarios, such as container hosted .NET applications, from development to production environments. Also, you will learn how to keep your configuration values securely stored using key vaults, container clusters and in pipeline based deployments and releases.
Flagging your features - a DevOps approach to continuous release
Your DevOps team wants to deliver business value as often and fast as possible. Ideally you want to release a new feature whenever it seems ready. With feature flags you can achieve this selective releasing, but how do you do this in a structure and maintainable way that fits well with DevOps practices?
In this session we will look at the implementation of feature flags in cloud native applications, the platform needed to support it and some strategies and patterns related to feature flagging, such as rings and A/B testing. You will learn how to build and maintain this using the Microsoft platform with .NET applications, Azure and Azure DevOps. Also, we will cover how to get feedback from the feature flags and loop it back to the deployment and release pipelines and environments to achieve an automated and stable system during release.
At the end of this session you know how to get started with feature flags for continuous release DevOps style.
Let’s get minimal: .NET 7 minimal APIs in ASP.NET Core
In .NET 7 there will be significant changes to the way you bootstrap an ASP.NET Core web application or API. It uses a number of new features in C# 9, 10 and 11 and the .NET framework to drastically reduces the code you need to define and start your app. It has been named Minimal Web APIs, but there is much more to it than just that. Time for us to take a look and discover what it is all about. During this session you will see the new ASP.NET Core approach, and learn how you can leverage this in your new applications from .NET 6 onwards. You will learn how to use dependency injection, new attributes, custom binding and changes in integration testing. Join me in this session to maximize your knowledge on minimal APIs.
Living past version 1.0 of your restful services: Web API versioning for ASP.NET Core
You have just successfully released your first Web API built in ASP.NET Core. Other applications are consuming the Web API and all is good. Then a newer version of your APIs needs to be build and you find that you have to deal with both new and old consumers. Versioning and backward compatibility becomes necessary all of a sudden.
This session will show you how to add versioning support to your ASP.NET Core Web APIs. We will look at implementing multiple versions, version routing, versioning strategies, version discovery and adding documentation from Swagger. You are going to learn what it takes to evolve your Web APIs from version 1.0 until deprecation, but also how clients can consume the right version of APIs.
Short: Learn all about versioning your Web APIs in ASP.NET Core. You will see when multiple versions are necessary and how to take care of hosting different versions, routing requests and using conventions, documentation and properly use version formats for long-term support of your web-based API.
Building intuitive command-line interfaces in .NET
The cross-platform story for .NET continues. More and more tooling uses a command-line interface to make it easy to execute complex tasks from a script or console. Microsoft has invested in this area for their own tooling, such as the dotnet CLI or project Tye. You can benefit from their efforts by using System.CommandLine to build your own CLI or parametrize your application startup with arguments and options.
The Microsoft .NET libraries hold a number of great packages to create intuitive CLIs, with commands that have features such as suggestions with tab-completion and typocorrections.
In this session you will learn how to implement commands, with arguments and options, and leverage the build-in functionality such as binding, validation, middle-ware, command-hierarchies, parsing and much more. We are going to cover practical examples and use-cases, plus tips and tricks for efficient development and debugging.
After this session you can are ready to go and build CLIs for your own .NET applications and tooling with minimal effort.
Coding 4 Fun: 8-bit game emulation in .NET
Retro gaming is coming to .NET. Did you know that it is really possible to emulate the game consoles from the eighties and nineties using the .NET Framework and cross-platform? You can use .NET Standard Libraries and MonoGame to develop an emulator to make your childhood computer games come to life on Windows 11, Linux and MacOS. This session will show you how game emulation works, how to program it in C# with Visual Studio 2022 or Visual Studio Code and create apps using MonoGame. With plenty of demos and nostalgia this session is a welcome break even if you do not intend to write an emulator of your own.
Dapr for building distributed .NET Core applications
Modern distributed applications require much more than just application logic. Features such as state management for services, communication using publish/subscribe messaging and event driven binding to cloud resources might be needed. Dapr introduces a runtime to offer such building blocks, and is less invasive in your application, allowing you to
pick-and-choose what you need. In this session we will look at the approach that the Dapr runtime takes with a sidecar architecture, separating application logic from the Dapr runtime components. You will also see what it takes to develop distributed applications in .NET Core using Dapr's features and how to bind to messaging infrastructure, cloud resources and use the actor programming model and client proxies. At the end you know what it takes to combine Dapr in your ASP.NET Core applications using routing, controllers or using gRPC clients.
Architecting .NET solutions in a Docker ecosystem
You must have noticed how Docker and containers is playing a more and more important part in .NET development. Docker support is everywhere, so it should be easy to build solutions based on container technology, right? But, it takes a bit more to architect and create a .NET solution that use Docker at its core. Many questions arise: How do you design a solution architecture that fits well with containers? Would I use .NET or .NET Core? What is a proper way to migrate to such an architecture? What changes in the .NET implementation from pre-Docker solutions with micro-services? Where do container orchestrators fit in and how do I build and deploy my solutions on a Docker container cluster, such as Azure Kubernetes Service?
These and many other questions will be answered in this session. You will learn how to design and architect your .NET solutions and get a flying start to create, build and run Docker-based containerized applications.
Building real world production-ready Web API's with .NET Core
You might have started building your microservices-based Web APIs using .NET Core. And you are ready to go into production. Did you think about hosting, scaling, monitoring, versioning, documentation, resiliency and logging? Because going into production with just your business logic is not enough. In this session you will learn how you have to build your evolving Web APIs using .NET Core and the Microsoft platform and run in a robust, hyper-scale production environment.
Server-less compute with .NET based Azure Functions
Azure Functions offer server-less cloud services and are the next evolution in distributed computing and hosting after containers. Join this session to learn how to develop Azure Functions using C# and .NET, and how to test, build and deploy to Azure. We will cover .NET programming details, architecture, internals and hosting. Also, you will learn how to set up a local development environment to build and host locally. After this session you are ready to design and create state of the art Azure Functions using .NET
Logging, tracing and metrics: instrumentation in .NET and Azure
Ever had production problems and found that you cannot debug to find the problem? Or that you need to find out where potential issues are coming from in your Azure cloud solution and you have no idea what is happening?
Your applications need to be instrumented with logging, tracing and metrics, so you can see what is going on where. In .NET logging and tracing are built into the framework. We will have a look at the differences between logging, tracing and instrumentation in general. You will learn how to use .NET to implement logging and tracing with best practices, do semantic logging, work with logging factories, trace providers. Also, you will learn how to instrument using Application Insights and add W3C compliant tracing for correlation across cloud resources in a distributed application. Finally, we will put everything together to see how your logs and traces can give a rich way to get insights into your applications and services running in the Azure cloud or container based solutions.
It depends: loving .NET Core dependency injection or not
.NET Core comes with its own dependency injection system, that you probably know from ASP.NET Core. In this session we will have a detailed look at all of the specifics of Microsoft's default DI system for .NET Core applications. You will learn how to properly use the Inversion of Control features, such as registering services, scopes, lifetimes, and how to resolve instances.
Armed with this DI knowledge, we will revisit ASP.NET Core and investigate bootstrapping and typical scenarios for middleware, background processes and resolving objects from MVC and Razor.
At the end there will be a deep dive into topics with service descriptors, implementation factories, do's and don'ts and pitfalls to avoid memory leaks in your implementation.
I don't feel so well… Integrating health checks in your .NET solutions
Do you have any idea how your ASP.NET Web Apps and APIs are functioning? Are they behaving healthily or in a degraded state? You might be able to tell from log information and telemetry data, but why not have them tell you how healthy they are themselves? ASP.NET Core introduced health endpoints that let your apps and APIs do just that. In this session you will learn how to make health checks an integral part of your solution. We will cover various types of health checks ranging from internal status, such as memory thresholds, to health based on external dependencies, such as databases and HTTP endpoints. Finally, you are going to see how this all can be used in a container cluster to allow the orchestrator to check for liveliness and readiness based on your health endpoints.
From .NET to .NET Core for cloud solutions
This workshop will focus on migrating your .NET Framework based solutions to .NET Core and designed to run in the cloud. During the workshop you are going to learn what:
- .NET Core 3.0 platform is all about
- Understand .NET Standard 1.0 to 2.1
- Changes required to migrate your .NET FX solution to .NET Core
- Apply cloud patterns in ASP.NET Core 3.0 web applications and APIs for resiliency and
- Apply container technology to implement cloud and container hosted .NET Core applications
- Use tooling and patterns to develop containers for Azure cloud
Getting your head around .NET Standard 2.1
The .NET Standard introduced a new way of creating highly portable .NET assemblies. The .NET Standard was mainly targeted at library developers. Now, .NET Standard 2.1 has much more impact on .NET developers of all platforms. And as it turns out, the .NET Standard is not trivial to understand. In this session you will learn what the .NET Standard is and how it is used to allow you to create cross-platform .NET applications. You are going to see how version 2.1 is a big step forwards for creating and migrating existing apps to new platforms such as .NET Core and the key differences with 2.0. You will get practical guidance to start migrating existing libraries and applications to .NET Standard 2.1, but also get to understand the internals. You are going to see how .NET Standard 2.1 works under the covers during build time and runtime, and how the standard is incorporated into the existing .NET platforms. At the end of the session, you've got your head around .NET Standard 2.1 and you are ready to use it in your .NET development with confidence and proper understanding.
Serverless .NET Solutions using Azure Functions
This workshop will start with the basics of server-less architectures and explain how Azure Functions play a part in building server-less solutions. You will learn how to develop Azure Functions using .NET Core and Visual Studio 2019. Next, you are going to build and deploy these with Azure DevOps using CI/CD. Also covered is the lifecycle management and operations of server-less solutions, with proxies, monitoring and zero-downtime deployments. Among the topics we will cover:
• Getting started with server-less event-driven architectures and Azure Functions
• Anatomy of an Azure Function: creating and dissecting your first functions
• Knowing your triggers and how to binding your inputs and outputs
• Long-running flows with Durable Extensions Framework
• Build and release of Azure Functions with Azure Pipelines
• Securing your solutions
• Automated provisioning of Azure Functions with Azure Resource Management templates
• Going to production: proxies, deployment slots
• Monitoring server-less solutions: Integrating Application Insights in Azure Functions and using Azure Monitor
Closing the loop: instrumenting your .NET applications with OpenTelemetry
You build it, run it and own it. Knowing how your application behaves is easy in your development environment, because you have better debugging capabilities there. It gets more complicated when you run in production. Getting feedback from your application and learning its behavior is essential to close the DevOps feedback loop.
In this session, you will learn what it takes to instrument your .NET application to get rich feedback in every stage of the lifecycle. We start by looking at the various ways to add logging, tracing, and metrics using the built-in .NET libraries. We will consume the telemetry data from your development environment with OpenTelemetry; no cloud required. Next, we will cover the production scenario and see how you can leverage Azure with Application Insights and Azure Monitor.
By the end of your session, you will have a good understanding how to add proper instrumentation with OpenTelemetry and to put it to good use during your entire development lifecycle.
Cloud aspirations: building cloud-native applications with .NET Aspire
In this workshop we will look at how you can build scalable, robust and observable cloud-native solutions built with .NET 8 and 9 using .NET Aspire. Microsoft has introduced .NET Aspire as an opinionated cloud-ready stack to create distributed application. It addresses cloud-native concerns such as observability, discoverability and composition.
We will start by examining typical distributed applications and their common architecture styles in the cloud, leveraging PaaS services from cloud providers with their resilience and scalability characteristics.
After this overview we will introduce the common concerns for distributed applications, such as observability, service discovery and configuration, and how .NET Aspire can help. You will see how you can build your applications with .NET Aspire, by making proper use of the orchestration, components and tooling it offers. We are also covering the .NET Aspire service discovery and connection management, discover the programming model and the developer workflow.
In the hands-on labs you will experience and practice this yourself. You will enhance an existing application by composing it using the .NET Aspire primitives of projects, containers and cloud resources. With guided exercises you can explore how your application changes with .NET Aspire, the way of working as a developer and DevOps engineer.
Finally, we are going to dive into the inner workings of .NET Aspire and see what happens under the covers during development and in production.
Whether you are maintaining an existing application on premise or are building brand new applications, this workshop will help you understand what .NET aspire can bring to you and how you can apply it in your application context.