Developing Distributed Applications with Azure and .NET Aspire

Who is the training for?

All public

Duration

3,00 day(s)

Language(s) of service

EN FR

Next session

Contact the training provider

Goals

Dive into the future of scalable software design with our course on Distributed Applications using Azure and .NET Aspire. This course is designed for developers looking to master the art of building robust, high-performance distributed systems. Use .NET Aspire to design, implement, and manage applications that are resilient, scalable, and ready to meet the demands of modern business environments. You will explore microservices architecture, learn best practices for inter-service communication, and utilize cloud-native technologies to deploy and manage your distributed applications. Whether you're building real-time data processing systems, complex web services, or scalable cloud solutions, Whether you're working on real-time data processing, complex web services, or scalable cloud solutions, this course gives you the skills you need.

Introduction to Distributed Applications

As your application matures, you might encounter some growing pains, this is a good sign you might want to step away from a monolithic approach. Distributed applications leverage the power of multiple computing resources to provide a more robust, scalable, and efficient system.

Application Architecture Throughout the Years
Containers: The Gateway to Distributed Applications
Docker Basics
Strengths and Challenges in Modern Application Architecture
.NET Aspire to the Rescue

.NET Aspire Overview

.NET Aspire is designed to simplify the development of distributed, observable, and production-ready applications using .NET. It provides a set of tools, libraries, and templates that streamline the process of building applications, particularly those that are cloud-native, meaning they are optimized to run in cloud environments.

The Pillars of .NET Aspire
Orchestration in C# with AppHost

Aspire Dashboard: Get the Best Developer Experience you can, for Free!

Observability, Resiliency and Health Checks using Service Defaults

.NET Aspire Deployment Options
LAB: Getting to Know .NET Aspire

Building Distributed Applications with .NET Aspire

So you've decided to build a distributed application, how do you get started and what will you need? In this module we take a look at some of the key building blocks of a distributed application such as APIs, client applications and data sources.

Basic Building Blocks of a Distributed Application
Tying the Building Blocks of your Application together
Connecting Your Projects to each other with Service Discovery

Should your Development Environment really try to mimic your Production
Environment?

LAB: Building a Distributed Application with .NET Aspire

Enhancing your Application with Pluggable Integrations

Now that you know how .NET Aspire can tie the parts of your application together, why not add some useful resources like a cache, a database, or basically any container you want?

What are .NET Aspire Integrations?
Commonly Used Integrations: Caching, Messaging, Storage,...
Hosting and Consuming Integrations
Configuring Integrations
LAB: Adding existing Integrations to your Application

Building a Microservice Architecture

How do you chop your application into multiple smaller components, called "microservices", and why would you do that? Here, we will show you how to create microservice-applications and introduce you to some key concepts of microservices like data isolation, resiliency, and communication.

Dealing with Evolution in an Application
Benefits and Drawbacks
Scaling
Communication: Client-Service, Service-Service, Event-Based
Data Isolation per Microservice
Integrating Containers and Microservices into a .NET Aspire Application

Asynchronous Communication

In this module, you will learn what event-based communication is and why it's such a great fit for microservices.

Communication Patterns
Event-Based Communication
Event Bus
Integration Events
Eventual Consistency

Synchronous Communication

In this module, you will learn how to make synchronous communication more reliable by using a number of patterns.

Problems with Direct Communication
Retry
Circuit Breaker
Sidecar Pattern
Solving Problems with Smart Service Defaults

Building Microservices with Dapr

Where do you run your containers? How do you store data? Which message broker will you use? The list of decisions you have to make goes on. But how do you shield your code against all those technical details? Dapr is a distributed application runtime that keeps your code platform-agnostic. This is done through an architecture of pluggable components. Swap out your database without even recompiling the code!

Dapr Overview
Installation
State Management
Service Invocation
Publish and Subscribe
Bindings
Observability
Secrets Management
LAB: Using Dapr with .NET Aspire

Azure for Container Overview

Azure has many constructs that have to do with containers and microservices. It's a bit overwhelming, really. This module will help you separate the sheep from the goats, to figure out exactly what you need.

Azure Container Registry
Hosting Containers: Container Instances, AKS, Service Fabric, ACA
Deploy with Containers: Web Apps and Functions

Azure Container Apps

Managing scalable containers on a Kubernetes cluster in Azure, but without the complexity. Sounds like a dream? It's not, this is exactly what Azure Container Apps are all about. In this module you will learn how to set up a serverless container solution using event-driven scaling.

Container Apps and Environments
Event-based Scaling with KEDA
Working with Revisions
Integrating with Dapr Components
Network and Ingress
Authentication and Service Connection

Deploying .NET Aspire Applications

We know Azure Container apps is the preferred deployment environment for .NET Aspire, but wouldn't it be great if we could deploy our app anywhere we want? and what about CI and CD? In this module we'll explore all our options.