What is .Net Aspire



Microsoft recently released the Net Aspire framework. It is part of .Net 8 and provides a lot of extra features on top of .Net 8. Although still in preview release, experts claim it to be the go-to choice for developing, testing, and deploying cloud-native applications, including microservices-based applications. In this article, we will explore it in detail, especially focusing on :
  • What problems does it solve?
  • Core features
  • .Net Aspire vs Kubernetes
  • Frequently asked questions
Let’s start by understanding why we needed .Net Aspire in the first place.

What problems does it solve?

Let’s review some of the challenges faced by developers that led to the creation of .Net Aspire framework.
  • Complex orchestration: Managing scattered services in distributed systems leads to service malfunctioning or poor coordination among services.
  • Service discovery challenges: Ineffective discovery can cause services to communicate with the wrong service (e.g., failing to find the video in a streaming platform).
  • Cloud-Native development complexity: Building scalable and resilient applications requires manual effort for resource management and fault tolerance, leading to performance issues and outages.
  • Limited observability: Lack of standard tools makes it difficult to monitor application health, diagnose bugs, and identify root causes quickly.

How .NET Aspire solves these challenges

  • Orchestration framework: Ensures smooth service interaction using a central system.
  • Service discovery: Enables services to find and communicate with each other effectively (e.g., using a discovery mechanism).
  • Cloud-Native development toolkit: Provides built-in features for:
    1. Resiliency: (APIs for handling failures)
    2. Scalability: (Automatic resource scaling)
    3. Health checks: (Monitoring service availability)
    4. Containerization: (SDK for container builds)
    5. Communication: (HTTP client factory, gRPC support)
  • Observability tools: Offers features for application monitoring and troubleshooting:
  1. Distributed tracing: Tracks requests across services for root cause analysis.
  2. OpenTelemetry SDK: Industry-standard observability framework.

Core features of .Net Aspire

Here are some of the salient features of .Net Aspire framework.


Orchestration mechanism

The design of .NET Aspire’s orchestration aims to enhance your local development experience by simplifying the management of your cloud-native app’s configuration and interconnections. This is achieved through the utilization of an app model that outlines the resources in your app and their relationships. These resources encompass projects, executables, containers, as well as external services and cloud resources that your app depends on. Within every .NET Aspire app, there is a designated App host project, where the app model is precisely defined using methods available on the interface IDistributedApplicationBuilder. Some breakthrough features related to orchestration are:
  • You can easily build, provision, deploy, configure, test, run, and observe your cloud application using .Net Aspire’s app model.
  • No need to manually manage your cloud-native app’s configuration and interconnections, .Net Aspire’s orchestration is designed to enhance your local development experience by simplifying these tasks.
  • Using the AppHost project, you can easily orchestrate all apps within the app model.
  • With .Net Aspire, you can now easily specify the .NET projects, containers, executables, and cloud resources that make up the application.
                                            AppHost project for orchestration of all apps in the app model. Source: Microsoft

Service discovery

.NET Aspire includes functionality for configuring service discovery at development and testing time. This functionality works by providing configuration in the format expected by the configuration-based endpoint resolver from the .NET Aspire AppHost project to the individual service projects added to the application model. Here is a glimpse of what you can achieve regarding service discovery:
  • Configure service discovery with Net Aspire’s configuration-based endpoint resolver.
  • Automated service discovery configuration for each service. NET Aspire automatically configures service projects introduced to the application model.
  • Easily manage services with many named endpoints. Named endpoints can be resolved by adding the endpoint name to the HTTP request URI host.
  • Set named endpoints in configuration for simpler management and use of numerous service endpoints.

Integrated health checks

.NET Aspire framework significantly enhances the health check capabilities of your applications. It provides built-in health check endpoints when the AddServiceDefaults and MapDefaultEndpoints methods are called from the Program.cs file. The /health endpoint shows whether the app is running normally and ready to receive requests. The app must pass all health checks to be considered ready to accept traffic after starting. The /alive endpoint indicates if an app is running or has crashed and must be restarted. The app is considered alive only if it passes all health checks tagged with the live tag.

Develop and test cloud-native apps locally

.NET Aspire framework significantly enhances the local development and testing experience for cloud-native applications. It provides a robust inner-loop networking system that allows your apps to communicate with each other in your development environment. Here are some of the breakthrough features:
  • NET Aspire automates networking tasks such as proxies, service bindings, endpoint setups, and launch profiles.
  • Launch profiles let you create app service bindings, environment variables, and launch options.
  • Add service bindings to your app with Net Aspire, either implicitly (via launch profiles) or manually (using WithEndpoint).
  • NET Aspire runs a proxy for each service binding and assigns a port for it to listen on. This avoids port conflicts and lets you access your app and services via predictable URLs.
                                                                         Inner-loop network diagram. Source: Microsoft

Telemetry / Observability

One of the primary objectives of .NET Aspire framework is to ensure that apps are straightforward to debug and diagnose. .NET Aspire components automatically set up logging, tracing, and metrics configurations, which are sometimes known as the pillars of observability. Let’s go through these pillars quickly.
  • Logging: Log events describe what’s happening as an app runs. A baseline set is enabled for .NET Aspire components by default, and more extensive logging can be enabled on-demand to diagnose particular problems.
  • Tracing: Traces correlate log events that are part of the same logical activity (e.g., the handling of a single request), even if they’re spread across multiple machines or processes.
  • Metrics: Metrics expose the performance and health characteristics of an app as simple numerical values. As a result, they have low-performance overhead, and many services configure them as always-on telemetry. This also makes them suitable for triggering alerts when potential problems are detected. Together, these types of telemetry allow you to gain insights into your application’s behavior and performance using various monitoring and analysis tools.

Frequently asked questions


How is .NET Aspire different from .NET 8?

It is an enhancement on top of .Net 8. If you are building cloud-native applications especially if they are based on microservices architecture, then you should use .Net Aspire on top of .Net 8.

Why use .NET Aspire for orchestration when I can use Docker Compose?

.NET Aspire provides a better experience that’s easy to get started and scales up to an orchestrator like Docker Compose using a real programming language, specifically C#.

How can I get started with .NET Aspire?

It is very easy. You just need to install .NET 8.0, .NET Aspire workload, Docker Desktop, and an IDE such as VSCode. VSCode has built-in starter apps for .Net Aspire as well.

Does .NET Aspire support all the features of .NET 8?

Yes, it does, and it adds additional capabilities for building cloud-native applications.

Why would I use .NET Aspire service discovery when Docker Compose has it built in and works with Kubernetes?

.NET Aspire service discovery APIs work with various providers such as Consul, Eureka, and Zookeeper, and work locally, backed by .NET’s IConfiguration abstraction.

OpenTelemetry is something that can already be used in .NET. Why would I use .NET Aspire?

While Grafana, Jaeger, and Prometheus can work with .NET, .NET Aspire provides a set of libraries and tools that make it easy to build applications that are observable. It integrates seamlessly with these tools and provides additional capabilities, such as a sophisticated dashboard for comprehensive app monitoring and inspection.

What is the release status of .Net Aspire?

Microsoft plans a new .NET Aspire preview release every month, leading to a stable release expected in the second quarter of 2024.

What is the difference between Net Aspire and Aspir8?

Aspir8 and .NET Aspire are separate tools. Aspir8 is a CLI tool that simplifies the deployment of microservices, while .NET Aspire is a full-fledge framework for building, and deploying cloud-native applications. If you are deploying microservices through Net Aspire, you will be implicitly using Aspir8 for deployment.

.Net Aspire Vs Kubernetes for microservices

Below are some of the important points when comparing Net Aspire versus Kubernetes.

.NET Aspire vs Kubernetes

.NET Aspire is not a replacement for Kubernetes. Instead, it complements Kubernetes. It works with various providers like Kubernetes and Consul for service discovery. .NET Aspire is not as production-ready as Kubernetes. It is still in the preview stage and is expected to mature into something production-ready in .NET 9. On the other hand, Kubernetes has been a top choice for container orchestration needs. Developing microservices using Net Aspire, and deploying them using Kubernetes is the best of both worlds.

Reduced need for Sidecars

.NET Aspire reduces the need for sidecars, leading to leaner cluster workloads. It simplifies the process of deploying microservices by providing a developer-friendly UI and a CLI tool.

Less complex than Kubernetes

.NET Aspire is less complex than Kubernetes. It simplifies cloud-native development by making it easy to discover, acquire, and configure essential dependencies for cloud-native apps. However, Kubernetes, being a cloud-agnostic container orchestration service, provides unparalleled flexibility and control over deployment environments.


Microsoft has released Net Aspire framework as an enhancement on top of .Net 8. This article has explored different breakthrough features that come with this framework. Whether it is service discovery, orchestration, monitoring, cloud-ready components, or its integration with existing industry-leading technologies like Kubernetes, Net Aspire seems to be the first choice for developing cloud-native systems. Although still in the preview release and not as production-ready as Kubernetes, it holds a lot of promise.