DOCSEARCHbyAlgolia
Submit Docs

.NET Aspire

website·Indexed 35 days ago

https://aspire.dev

A code-first control plane for modeling, running, observing, and deploying distributed applications. It provides a resource model to manage polyglot services, containers, and executables using C# or TypeScript AppHosts, featuring a developer dashboard, service discovery, and tools for migrating from Docker Compose.

Tokens
611.1K
Snippets
3K
Records
4K
Agent score
72%

What's inside .NET Aspire

  1. Overview of Redis integrations in .NET Aspire

    The .NET Aspire Redis integration allows you to model a Redis server as a first-class resource within your AppHost. This enables zero-config local development using the docker.io/library/redis image with automatically generated passwords. The integration provides consistent connection information across multiple languages (C#, TypeScript, Python, Go) via environment variables, built-in health checks for orchestrators, and observability through the Aspire dashboard. It also supports drop-in RESP-compatible alternatives like Valkey and Garnet.

  2. Overview of KurrentDB integration for .NET Aspire

    The KurrentDB integration for .NET Aspire allows you to model a KurrentDB event store (an open-source, immutable, append-only log database) as a first-class resource within an Aspire AppHost. This integration automates local development by using the docker.kurrent.io/kurrent-latest/kurrentdb container image and provides consistent connection information via environment variables across multiple languages (C#, TypeScript, Python, Go). Key benefits include zero-config local setup, built-in health checks, dashboard observability for logs and telemetry, and a dedicated C# client integration via the CommunityToolkit.Aspire.KurrentDB package.

  3. Overview of MongoDB integrations in .NET Aspire

    The .NET Aspire MongoDB integration allows developers to model MongoDB servers and databases as first-class resources within an AppHost. It automates the provisioning of MongoDB containers using the docker.io/library/mongo image, generates credentials automatically, and injects connection properties as environment variables into consuming applications regardless of the programming language (C#, TypeScript, Python, Go, etc.).

    Key benefits include:

    • Zero-config local development: Automatic container management and credential generation.
    • Cross-language consistency: Predictable environment variables for connection info.
    • Observability: Built-in health checks and integration with the Aspire dashboard for logs and telemetry.
    • C# Client Support: Dedicated packages (Aspire.MongoDB.Driver or Aspire.MongoDB.Driver.v3) for dependency injection and OpenTelemetry.
    • Admin UI: Ability to deploy Mongo Express as a web admin interface via a single API call.

  4. Overview of EF Core Azure Cosmos DB integration for .NET Aspire

    The Aspire EF Core Azure Cosmos DB integration allows developers to model Cosmos DB accounts, databases, and containers as first-class resources within an Aspire AppHost and interact with them using Entity Framework Core (DbContext and LINQ) in C# consuming applications.

    Key benefits include:

    • Zero-config local development: Automatically runs the Azure Cosmos DB Emulator via the mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator container image.
    • Automatic Dependency Injection: The AddCosmosDbContext method registers the DbContext and handles connection wiring from the Aspire resource name.
    • Observability: Built-in health checks and integration with the Aspire dashboard for logs, status, and telemetry.
    • Deployment: The AppHost model automatically generates Bicep files to provision real Azure Cosmos DB accounts during deployment.

  5. Overview of Aspire Go hosting integration

    The Aspire Go hosting integration allows you to run Go applications alongside other Aspire resources from the AppHost. During development, Aspire uses the local Go toolchain (e.g., go run .) to execute apps, providing service discovery, endpoint configuration, and dashboard visibility (logs, status, and lifecycle controls). For deployment, Aspire can use existing Dockerfiles or generate container build artifacts automatically.

  6. Overview of the Community Toolkit PowerShell integration for Aspire

    The Community Toolkit PowerShell integration allows you to run managed PowerShell scripts within an Aspire AppHost. It uses an in-process runspace pool to host script resources, enabling you to model setup, provisioning, and administrative scripts as application resources. This integration allows you to monitor script logs and states via the Aspire dashboard and define execution dependencies between scripts.

  7. Overview of distributed application testing in Aspire

    Aspire supports functional and integration testing of distributed applications using the Aspire.Hosting.Testing NuGet package. The core component is the DistributedApplicationTestingBuilder, which acts as a test harness to launch the AppHost project with built-in instrumentation. This allows developers to use familiar types like IDistributedApplicationBuilder and DistributedApplication to manage the lifecycle of the host and assert on resource behavior.

  8. Overview of SQL Server integrations in .NET Aspire

    The .NET Aspire SQL Server integration allows developers to model SQL Server instances and databases as first-class resources within an AppHost. It automates the provisioning of SQL Server containers using the mcr.microsoft.com/mssql/server image and manages the injection of connection properties into consuming applications regardless of the programming language used. Key benefits include zero-config local development with auto-generated credentials, built-in health checks, dashboard observability (logs and telemetry), and a dedicated C# client integration via the Aspire.Microsoft.Data.SqlClient package.

  9. Overview of Milvus integration with .NET Aspire

    The .NET Aspire Milvus integration allows developers to model a Milvus vector database server and its databases as first-class resources within an AppHost. This integration automates the provisioning of the Milvus server (using the milvusdb/milvus container image), manages credentials, and injects connection information into consuming applications as environment variables. This approach supports multi-language consumers (C#, TypeScript, Python, Go) and provides built-in health checks and observability via the Aspire dashboard. Additionally, the Attu admin GUI can be optionally deployed alongside the server.

  10. Overview of Aspire MCP server for application observability

    The Aspire MCP server exposes application observability data to AI coding agents, allowing them to query resource status, read logs, inspect distributed traces, and execute resource commands. It uses the same runtime evidence found in the Aspire dashboard. The server is started via the aspire agent mcp CLI command and uses the STDIO transport protocol, meaning it runs as a local child process with no open network ports.

  11. Overview of Aspire SQLite Integration

    The Aspire SQLite integration (provided by the Aspire Community Toolkit) allows developers to model a SQLite database as a first-class resource within an Aspire AppHost. Since SQLite is a serverless, file-based engine, the integration manages the database file path and injects it as an environment variable into consuming applications, regardless of the programming language used (C#, TypeScript, Python, Go, etc.).

    Key benefits include:

    • Zero Infrastructure: No containers or servers to configure for the database itself.
    • Cross-Language Consistency: Predictable environment variable formats for connection info.
    • Developer Tooling: Optional browser-based UI via WithSqliteWeb (using the sqlite-web container) for querying and inspecting data.
    • C# Integration: Dedicated support for dependency injection, health checks, and OpenTelemetry via the CommunityToolkit.Aspire.Microsoft.Data.Sqlite package.

  12. Overview of Redis distributed caching in .NET Aspire

    The Redis distributed caching integration provides a Redis-backed implementation of the standard ASP.NET Core IDistributedCache interface. It allows developers to use Redis for session state, data protection, and [OutputCache] without manually managing connection strings or complex service registrations.

    Key benefits include:

    • Automatic Registration: AddRedisDistributedCache registers IDistributedCache and the underlying IConnectionMultiplexer.
    • Health Checks: Built-in checks verify Redis reachability before the app reports as healthy.
    • Observability: Integrated OpenTelemetry for logging, distributed tracing, and metrics.
    • Compatibility: Works transparently with ASP.NET Core higher-level abstractions.

    Note: This specific integration (Aspire.StackExchange.Redis.DistributedCaching) is for C# apps. TypeScript, Go, and Python consumers should use the standard Redis client integration instead.