skip to content

Publishing & Dashboard

Aspire's dashboard shows resources, logs, traces and metrics while developing, and aspire publish and deploy turn the AppHost into Compose, Kubernetes or Azure output. Interviewers ask what ships.

on this pageshow

explore

questions

6

What does the Aspire dashboard show while an Aspire 13 AppHost runs, and how do you get into it?

level: juniorimportance: must knowfreq 50%

answer

  1. started by the AppHost, not deployed
  2. Resources, Console logs, Structured logs, Traces, Metrics
  3. login URL with a browser token
  4. telemetry arrives over OTLP
  5. 13.6 keeps ten past runs in SQLite

basics

~20 s

The Aspire dashboard is a local web UI the AppHost starts: it lists each resource's state, endpoints and environment, and shows console logs, structured logs, traces and metrics. You enter through the login URL with a browser token that aspire run prints.

solid answer

~40 s

When `aspire run` starts an AppHost, it also launches the dashboard and prints a URL containing a one-time browser token; opening it logs you in. The **Resources** page lists each project, container and executable with its state, health, endpoints and environment variables, and lets you stop, start or restart it. **Console logs** shows each resource's stdout and stderr. **Structured logs**, **Traces** and **Metrics** show OpenTelemetry data the services export over OTLP — for .NET services that is what `AddServiceDefaults` wires up — so one request through the ticketing API and its checkout worker appears as a single trace. Since Aspire 13.6 the dashboard stores resources and telemetry in SQLite and keeps up to ten completed runs per application for comparison. It is a development and short-term diagnostics tool, not a production telemetry backend.

code

bash · 6 lines
bash
# Start the ticketing AppHost; the CLI prints the dashboard login URL
aspire run --apphost ./src/Ticketing.AppHost/Ticketing.AppHost.csproj

# Query the same telemetry from a terminal
aspire otel traces
aspire otel logs

go deeper

for a junior

Recall the five areas — Resources, Console logs, Structured logs, Traces, Metrics — and that you log in through the token URL aspire run prints.

for a middle

Explain why Traces and Metrics depend on each service exporting OTLP, while Resources and Console logs come from the AppHost itself.

for a senior

Use the dashboard to diagnose a cross-service request, and treat its data as sensitive: secrets in environment variables, persisted to SQLite from 13.6 on.

for a principal

Draw the line between the dashboard as a developer tool and the production observability stack, so teams do not mistake one for the other.

## What the dashboard is The **Aspire dashboard** is a web application that ships with Aspire and starts automatically when an **AppHost** runs — the project that describes the services and backing resources of a distributed app. In an event-ticketing solution the AppHost starts the ticketing API, a checkout worker, PostgreSQL and Redis, and the dashboard becomes the single place to watch all of them. It is a development tool: nothing in the services depends on it, and it is not the system you point production alerting at. ## Getting in 1. `aspire run` builds and starts the AppHost. 2. The CLI prints the dashboard URL, which includes a **browser token** as a `login?t=` query parameter. 3. Opening that URL logs the browser in; opening the bare URL shows a login page that asks for the token. Visual Studio and VS Code log the browser in automatically. The token exists because the dashboard shows environment variables, connection strings and logs — data worth protecting even on a laptop. The dashboard also supports OpenID Connect sign-in, and an anonymous mode that should stay a local-only choice. ## The pages | Page | What it shows | Where the data comes from | |---|---|---| | **Resources** | each project, container, executable and parameter with state, health, endpoints, environment variables and actions (stop, start, restart) | the AppHost's resource model | | **Console logs** | raw stdout/stderr per resource | process and container output captured by the AppHost | | **Structured logs** | log records with level, category, message template and attributes, filterable | OTLP log export from each service | | **Traces** | distributed traces as span waterfalls across services, databases and caches | OTLP trace export | | **Metrics** | instruments such as request duration and active connections, as charts and tables | OTLP metric export | The first two pages work for any resource because the AppHost owns the processes. The last three only fill up when a service **exports OpenTelemetry**. The AppHost passes each resource an `OTEL_EXPORTER_OTLP_ENDPOINT` pointing at the dashboard; a .NET service built from the ServiceDefaults project exports when that variable is set. A service with no OpenTelemetry setup still appears on Resources and Console logs, but never in Traces. ## Reading one request When a fan buys a ticket, the trace for `POST /orders` shows the API span, the outgoing HTTP call to the checkout worker, the EF Core command to PostgreSQL and the Redis call, each with timings. The trace details page has a **View Logs** button that opens Structured logs filtered to that request, which is usually the fastest way to find which hop failed and why. ## Aspire 13.6: runs are kept Aspire 13.6 added run history: the dashboard now stores resource snapshots and telemetry in a versioned **SQLite** database, so a completed run can be revisited after the AppHost stops. - The dashboard launched by an AppHost uses **Run** persistence: a new database per run, a run selector in the header, and up to **ten** unpinned completed runs kept per application; pinned runs do not count. - Historical runs are read-only: resource commands, clearing and importing telemetry are disabled. - Telemetry is still capped — by default 100,000 log records, 100,000 traces and 50,000 metric points — and the oldest data is evicted beyond that. - The database can contain secrets, such as environment-variable values, unredacted; treat the data directory accordingly. ## What it is not - Not a production monitoring system: no alerting, no replication, no long retention. - Not required by the services: stopping the dashboard changes nothing about how they run. - Not where your services' telemetry is configured: exporters and instrumentation live in each service.

  • The checkout worker shows Running on the Resources page but never appears in Traces. Why?
    Resources and Console logs come from the AppHost, which owns the process; Traces only shows spans a service exports over OTLP. The worker either lacks OpenTelemetry setup — typically a missing `AddServiceDefaults()` call — or exports somewhere other than the `OTEL_EXPORTER_OTLP_ENDPOINT` the AppHost injected.
  • Is anonymous access to the dashboard acceptable?
    Only for a dashboard bound to your own machine. The dashboard shows environment variables, connection strings and logs, so the default browser-token login, or OpenID Connect where it is shared, protects data that often includes secrets. The 13.6 SQLite store raises the stakes, because the same values persist on disk after the run ends.

  • The dashboard collects traces from any service automatically, with no exporter in the service.
  • The dashboard is deployed with the app and serves as production monitoring.
  • Console logs and Structured logs are the same data shown twice.
  • Telemetry is always lost when the AppHost stops, even on Aspire 13.6.
  • The dashboard needs no login because it only runs on localhost.

Assumes Aspire 13.6: SQLite-backed persistence, the run selector and the ten retained runs arrived in 13.6, so earlier dashboards offer no history of completed runs.

open as a page

Why did .NET Aspire 9.5 become Aspire 13, and what changes when you upgrade an Aspire 9 solution to 13?

level: middleimportance: should knowfreq 30%

basics

~20 s

At 13.0 (November 2025) .NET Aspire dropped its .NET prefix, moved its docs to aspire.dev and jumped from 9.5 to 13, with no stated reason for skipping 10 to 12. Upgrading needs the .NET 10 SDK and runs through aspire update.

open as a page

An Aspire 13 event-ticketing AppHost must ship to Docker Compose on an on-premises host and to Azure Container Apps in production; how do you model that?

level: seniorimportance: should knowfreq 20%

basics

~10 s

Add AddDockerComposeEnvironment and AddAzureContainerAppEnvironment to the AppHost and either branch on builder.Environment so each deploy sees one target, or bind every compute resource with WithComputeEnvironment. Then aspire deploy --environment picks the run.

open as a page

In Aspire 13, what is the difference between aspire publish and aspire deploy, and what must the AppHost contain for either to do anything?

level: seniorimportance: should knowfreq 30%

basics

~20 s

aspire publish turns the AppHost model into target artifacts — Compose files, Helm charts, Bicep — with secrets left as placeholders; aspire deploy generates, resolves parameters and applies the deployment itself. Both need a compute environment resource, or they do nothing.

open as a page

How do you run the Aspire 13 dashboard standalone, without an AppHost, and what does it lose in that mode?

level: middleimportance: nice to knowfreq 25%

basics

~20 s

Run aspire dashboard run, or the mcr.microsoft.com/dotnet/aspire-dashboard container, and point each app's OTLP exporter at it. Standalone, it shows structured logs, traces and metrics only: no resource states, console logs or start and stop controls, because no AppHost feeds it.

open as a page

What was the Aspire deployment manifest, why is it deprecated in Aspire 13, and where does azd still fit in deploying an Aspire app?

level: seniorimportance: nice to knowfreq 15%

basics

~20 s

The deployment manifest was a JSON description of the AppHost's resources, bindings and parameters that azd turned into Azure resources. Aspire 13 deprecates it for aspire publish and aspire deploy; azd still consumes it in existing workflows.

open as a page