Explore a curated collection of official Aspire sample projects. Each sample is a fully functional application
you can clone and run to learn patterns for databases, messaging, cloud services, and more.
Browse a product catalog served by the Catalog service and add items to a cart held by the Basket service. Built with Aspire.
The app consists of four .NET services:
AspireShop.Frontend: This is an ASP.NET Core Blazor app that displays a paginated catalog of products and allows users to add products to a shopping cart.
AspireShop.CatalogService: This is an HTTP API that provides access to the catalog of products stored in a PostgreSQL database.
AspireShop.CatalogDbManager: This is an HTTP API that manages the initialization and updating of the catalog database.
AspireShop.BasketService: This is a gRPC service that provides access to the shopping cart stored in Redis.
The app also includes a .NET class library project, AspireShop.ServiceDefaults, that contains the code-based defaults used by the .NET service projects.
The app consists of two services:
ImageGallery.Frontend: This is a Blazor app that displays a for uploading of images, showing thumbnails of images in a grid.
ImageGallery.Functions: This is an Azure Function triggered by the arrival of a new blob using a Functions Blob Trigger.
The app also includes a class library project, ImageGallery.ServiceDefaults, that contains the service defaults used by the service projects, and the ImageGallery.AppHost Aspire App Host project.
This sample demonstrates using the Aspire JavaScript hosting integration to configure and run client-side applications.
The app consists of five services:
AspireJavaScript.MinimalApi: This is an HTTP API that returns randomly generated weather forecast data.
AspireJavaScript.Angular: An Angular app that consumes the weather forecast API and displays it with a featured-day hero and supporting day cards.
AspireJavaScript.React: A React app (Webpack) that consumes the weather forecast API and displays the forecast.
AspireJavaScript.Vue: A Vue app that consumes the weather forecast API and presents the forecast as a swipeable, keyboard-navigable day-by-day carousel.
AspireJavaScript.Vite: A React + Vite + TypeScript app that consumes the weather forecast API and displays the forecast.
The four front ends all render the same weather data, but each one wears a completely different design identity — the point of the sample is to compare the frameworks side by side, so we lean into that contrast:
| Front end | Design identity | CSS approach | Icon set |
| --- | --- | --- | --- |
| Angular | Material 3 "expressive" — dynamic tonal color, elevated surfaces | Angular Material + SCSS | Material Symbols |
| React | Neo-brutalism — thick borders, hard offset shadows, chunky type | CSS Modules | Phosphor |
| Vue | Forecast carousel — soft cards, Vue-green gradients, day-by-day navigation | Scoped CSS + custom properties | Lucide |
| Vite | Retro synthwave — neon sun, 80s grid horizon | Tailwind CSS | Tabler |
Every front end is keyboard operable, ships a skip link, announces async state with aria-live, honors prefers-reduced-motion and prefers-color-scheme, and passes an automated axe-core accessibility scan in both light and dark themes.
This sample demonstrates integrating a Node.js app and an ASP.NET Core HTTP API using Aspire.
The sample consists of two apps:
NodeFrontend: This is a simple Express-based Node.js app that renders an almanac-style weather forecast retrieved from a backend API and utilizes a Redis cache.
AspireWithNode.AspNetCoreApi: This is an ASP.NET Core HTTP API that returns randomly generated weather forecast data.
This sample demonstrates integrating a FastAPI (Python) app and a JavaScript frontend using Aspire.
The sample consists of two apps:
app: This is a simple FastAPI-based Python app that returns randomly generated weather forecast data.
frontend: This is a Vite-based React app that renders the weather forecast data.
This sample demonstrates working with client apps such as WinForms, WPF, etc., in an Aspire app, such that the client app is launched along with the AppHost project, can resolve services via service discovery, and logs, traces, and metrics are sent via OpenTelemetry to the dashboard.
Both client apps share one Skyline weather-companion identity rendered two ways: the WinForms client in a light Dawn palette and the WPF client in a dark Dusk palette. Each calls the backend weather API, renders the forecast as accessible cards, and streams its logs, traces, and metrics to the Aspire dashboard via OpenTelemetry.
The app is based on the Aspire Starter App template, with the following additional elements:
ClientAppsIntegration.WinForms: This is a WinForms application that displays the results of calling the weather API service application.
ClientAppsIntegration.WPF: This is a WPF application that displays the results of calling the weather API service application.
ClientAppsIntegration.AppDefaults: This is a class library that defines the default configuration for orchestrated apps. It's a more general version of the typical ServiceDefaults class library that's included in Aspire apps. The ClientAppsIntegration.WinForms and ClientAppsIntegration.WPF projects reference this project and calls its AddAppDefaults() method.
ClientAppsIntegration.ServiceDefaults: This has been modified from the default ServiceDefaults template to be based on and extend the ClientAppsIntegration.AppDefaults class library. The ClientAppsIntegration.ApiService project references this project and calls its AddServiceDefaults() method.
This sample demonstrates integrating applications into an Aspire app via Dockerfiles and container-based builds. This is especially helpful to integrate applications written in languages that Aspire does not have a native integration for, or to reduce the prerequisites required to run the application.
The sample integrates a simple app written using Go and the Gin Web Framework by using a Dockerfile:
ginapp: This is a simple "Hello, World" HTTP API that returns a JSON object like { "message": "Hello, World!" } from / and sends OpenTelemetry instrumentation to the Aspire dashboard.
This sample demonstrates how to write custom resources for Aspire hosting integrations. This is useful when you want to integrate something into the Aspire development experience as a resource that isn't an executable or container. Custom resources can particpate in the Aspire development experience, including the dashboard, and can be used to integrate with other tools or services.
Custom resources are defined using C# and generally consist of a class that implements the IResource interface and some extension methods to enable adding them to an IDistributedApplicationBuilder. Custom resources can publish and respond to events to give them "life" and allow them to interact with the rest of the Aspire application.
In this sample, we define a TalkingClock custom resource that spawns child ClockHand resources that tick on and off every second. We also define a TestResource custom resource that simply cycles through a set of states.
Read more about the Aspire resource model here.
This sample demonstrates working with database containers in an Aspire app, using the features of the underlying container image to modify the default database created during container startup. This is especially helpful when not using an ORM like Entity Framework Core that can run migrations on application startup (e.g., as in the Aspire Shop sample) and handle cases when the database configured in the AppHost is not yet created.
The app uses the following database container types:
Microsoft SQL Server
MySQL
PostgreSQL
The app consists of an API service:
ContainerDatabases.ApiService: This is an HTTP API that returns data from each of the configured databases.
This sample demonstrates how to use Entity Framework Core's migrations feature with Aspire.
The sample has three important projects:
DatabaseMigrations.ApiService - A web app that uses the database.
DatabaseMigrations.MigrationService - A background worker app that applies migrations when it starts up.
DatabaseMigrations.ApiModel - The EF Core context and entity types. This project is used by both the API and migration service.
DatabaseMigrations.ApiService and DatabaseMigrations.MigrationService reference a SQL Server resource. During local development the SQL Server resource is launched in a container.
REST API built with Go and chi router, using in-memory storage with thread-safe operations. Opening the running app in a browser lands on a themed Scalar API reference—a polished, Go-cyan developer portal generated from the service's OpenAPI 3.1 document—while API clients keep receiving JSON.
This sample demonstrates a TypeScript AppHost that runs the Go API directly during local development and switches to a checked-in Dockerfile for Docker Compose publishing.
This sample demonstrates configuring ASP.NET Core Health Checks and running the ASP.NET Core HealthChecksUI container with Aspire.
The sample is based on the Aspire Starter App project template and thus consists of a frontend web app that communicates with a backend ASP.NET Core API service and a Redis cache.
The frontend web app shows the health of the sample's services: a status overview, per-service uptime and latency tiles, a page that runs an on-demand health probe, and a live forecast streamed from the API service. It supports both light and dark themes:
Lumina media library, light theme
Lumina media library, dark theme
Upload images to Azure Blob Storage with queue-triggered thumbnail generation. Demonstrates event-driven Container Apps Jobs with queue-based autoscaling, managed identity authentication, and Azure SQL free tier - can run entirely within Azure free tier limits.
The Lumina front end is a productized media library built with React, TypeScript, CSS Modules and Heroicons. It ships light and dark themes (honoring prefers-color-scheme), an accessible drag-and-drop upload flow, live thumbnail polling and a keyboard-operable lightbox.
This is a simple .NET app that shows off collecting metrics with OpenTelemetry and exporting them to Prometheus and Grafana for reporting.
The instrumented app is a small web UI that emits OpenTelemetry metrics. Click around it — the Weather feed and the Auth Required flow — to generate the request traffic that shows up on the Grafana dashboard above. It supports both light and dark themes:
This is a simple .NET app that shows how to use Orleans with Aspire orchestration.
The voting frontend lets you create a poll, share its link, and vote on it. Vote totals are tracked by an Orleans grain and update in real time across every connected viewer. It supports both light and dark themes.
Create a poll, share the link, and watch the votes roll in:
FastAPI REST API with PostgreSQL database using Aspire Python support.
This sample demonstrates Aspire 13's polyglot platform support for Python applications, showcasing a simple CRUD API built with FastAPI and PostgreSQL.
It also ships a bespoke, on-brand Scalar API reference as its developer-facing UX — a themed FastAPI/Python developer portal served at /scalar, with the classic Swagger UI still available at /docs.
[!NOTE]
The screenshots above show a deterministic, stubbed conversation captured for
documentation. Live OpenAI responses require your own API key (see below) and
were not exercised when these images were generated.
Python FastAPI AI agent with OpenAI integration demonstrating AI workloads with Aspire.
This sample demonstrates Aspire 13's Python support combined with AI workloads, showcasing a Python-based AI chat agent powered by OpenAI.
The uploaded document list, answer, and cited passages shown above are illustrative — an OpenAI API key is required for live embeddings and answers. The empty-document and upload error states are captured against the real backend.
Upload documents and ask questions using Retrieval Augmented Generation with vector search.
View telemetry from any app in the Aspire dashboard. The dashboard supports running standalone, and apps configured with an OpenTelemetry SDK can send it data.
This sample is a .NET console app that downloads data from NuGet. The app sends telemetry to the Aspire dashboard which is viewed in the dashboard telemetry UI.
This sample demonstrates how to configure a SQL Server container to use a persistent volume in Aspire, so that the data is persisted across app launches. This method can be used to persist data across instances of other container types configured in Aspire apps too, e.g. PostgreSQL, Redis, etc.
The app consists of a single service, VolumeMount.BlazorWeb, that is configured with a SQL Server container instance via the AppHost project. PostgreSQL and Azure Storage data services are also configured in the AppHost and Blazor projects for demonstration and experimentation purposes. This Blazor Web app has been setup to use ASP.NET Core Identity for local user account registration and authentication, including Blazor identity UI. Using a persistent volume means that user accounts created when running locally are persisted across launches of the app.
[!NOTE]
The web front end wears a bespoke "Vault" identity — a split-screen authentication experience, a custom design-token system, distinct iconography, and full light/dark theming — tuned to meet WCAG 2.2 AA (with AAA contrast on body text).
The app also includes a class library project, VolumeMount.Data, that contains the Entity Framework Core data model and migrations, a worker service project, VolumeMount.MigrationService, that applies any pending database migrations on startup before the web front end starts, and a standard class library project, VolumeMount.ServiceDefaults, that contains the service defaults used by the service projects.
