From 8cfc2e12da168ce80e50a3aebb456ec1abd1dc19 Mon Sep 17 00:00:00 2001 From: David Pine Date: Thu, 26 Jun 2025 11:57:05 -0500 Subject: [PATCH 1/4] Initial update to simplify overview --- docs/get-started/aspire-overview.md | 117 ++++++++++++---------------- 1 file changed, 49 insertions(+), 68 deletions(-) diff --git a/docs/get-started/aspire-overview.md b/docs/get-started/aspire-overview.md index b328326109..d7351a867a 100644 --- a/docs/get-started/aspire-overview.md +++ b/docs/get-started/aspire-overview.md @@ -1,101 +1,82 @@ --- -title: .NET Aspire overview -description: Learn about .NET Aspire, an application stack designed to improve the experience of building distributed applications. -ms.date: 03/26/2025 +title: Aspire overview +description: Learn about Aspire, an application stack designed to improve the experience of building distributed applications. +ms.date: 06/26/2025 --- -# .NET Aspire overview +# Aspire overview -:::row::: -:::column::: +Aspire streamlines building, running, debugging, and deploying distributed apps. Picture your app as a set of services, databases, and frontends—when they're deployed, they all work together seamlessly, but during development they need to be individually started and connected. With Aspire, you get a unified toolchain that eliminates complex configs and makes local debugging effortless. Launch and debug your entire app with a single command. Ready to deploy? Aspire lets you publish anywhere—Kubernetes, the cloud, or your own servers. It's also fully extensible, so you can integrate your favorite tools and services with ease. -:::image type="icon" border="false" source="../../assets/dotnet-aspire-logo-128.svg"::: +For the official support information, see the [Aspire Support Policy](https://dotnet.microsoft.com/platform/support/policy/aspire). -:::column-end::: -:::column span="3"::: +## The app host -.NET Aspire provides tools, templates, and packages to help you build observable, production-ready apps. Delivered through NuGet packages, .NET Aspire simplifies common challenges in modern app development. Today's apps often rely on multiple services like databases, messaging, and caching, many supported by [.NET Aspire Integrations](../fundamentals/integrations-overview.md). For the official support information, see the [.NET Aspire Support Policy](https://dotnet.microsoft.com/platform/support/policy/aspire). +Aspire's app host is where you define your app's services and dependencies in code—no complex configs required. Easily map out your architecture and let Aspire handle the local orchestration, so you can focus on building features. -:::column-end::: -:::row-end::: - -## Why .NET Aspire? - -.NET Aspire improves the experience of building apps that have a variety of projects and resources. With dev-time productivity enhancements that emulate deployed scenarios, you can quickly develop interconnected apps. Designed for flexibility, .NET Aspire allows you to replace or extend parts with your preferred tools and workflows. Key features include: - -- [**Dev-Time Orchestration**](#dev-time-orchestration): .NET Aspire provides features for running and connecting multi-project applications, container resources, and other dependencies for [local development environments](../fundamentals/networking-overview.md). -- [**Integrations**](#net-aspire-integrations): .NET Aspire integrations are NuGet packages for commonly used services, such as Redis or Postgres, with standardized interfaces ensuring they connect consistently and seamlessly with your app. -- [**Tooling**](#project-templates-and-tooling): .NET Aspire comes with project templates and tooling experiences for Visual Studio, Visual Studio Code, and the [.NET CLI](/dotnet/core/tools/) to help you create and interact with .NET Aspire projects. - -## Dev-time orchestration - -In .NET Aspire, "orchestration" primarily focuses on enhancing the _local development_ experience by simplifying the management of your app's configuration and interconnections. It's important to note that .NET Aspire's orchestration isn't intended to replace the robust systems used in production environments, such as [Kubernetes](../deployment/overview.md#deploy-to-kubernetes). Instead, it's a set of abstractions that streamline the setup of service discovery, environment variables, and container configurations, eliminating the need to deal with low-level implementation details. With .NET Aspire, your code has a consistent bootstrapping experience on any dev machine without the need for complex manual steps, making it easier to manage during the development phase. - -.NET Aspire orchestration assists with the following concerns: - -- **App composition**: Specify the .NET projects, containers, executables, and cloud resources that make up the application. -- **Service discovery and connection string management**: The app host injects the right connection strings, network configurations, and service discovery information to simplify the developer experience. - -For example, using .NET Aspire, the following code creates a local Redis container resource, waits for it to become available, and then configures the appropriate connection string in the `"frontend"` project with a few helper method calls: +A simple example might represent a common three-tier architecture with a frontend that depends on an API, which in turn connects to a database. This could be represented in the app host as shown in the following code: ```csharp -// Create a distributed application builder given the command line arguments. var builder = DistributedApplication.CreateBuilder(args); -// Add a Redis server to the application. -var cache = builder.AddRedis("cache"); +// Add database service +var postgres = builder.AddPostgres("db") + .AddDatabase("appdata") + .WithDataVolume(); -// Add the frontend project to the application and configure it to use the -// Redis server, defined as a referenced dependency. -builder.AddProject("frontend") - .WithReference(cache) - .WaitFor(cache); -``` +// Add API service and reference the database +var api = builder.AddProject("api") + .WithReference(postgres) + .WaitFor(postgres); -For more information, see [.NET Aspire orchestration overview](../fundamentals/app-host-overview.md). +// Add frontend service and reference the API +var frontend = builder.AddProject("frontend") + .WithReference(api); -> [!IMPORTANT] -> The call to creates a new Redis container in your local dev environment. If you'd rather use an existing Redis instance, you can use the method to reference an existing connection string. For more information, see [Reference existing resources](../fundamentals/app-host-overview.md#reference-existing-resources). +builder.Build().Run(); +``` -## .NET Aspire integrations +Regardless of the language you choose, Aspire provides a consistent way to define your app's architecture. You can easily add services, set up dependencies, and configure how they interact—all in a straightforward, code-first manner. -[.NET Aspire integrations](../fundamentals/integrations-overview.md) are NuGet packages designed to simplify connections to popular services and platforms, such as Redis or PostgreSQL. .NET Aspire integrations handle cloud resource setup and interaction for you through standardized patterns, such as adding health checks and telemetry. Integrations are two-fold - ["hosting" integrations](../fundamentals/integrations-overview.md#hosting-integrations) represents the service you're connecting to, and ["client" integrations](../fundamentals/integrations-overview.md#client-integrations) represents the client or consumer of that service. In other words, for many hosting packages there's a corresponding client package that handles the service connection within your code. +For more information, see [Aspire orchestration overview](../fundamentals/app-host-overview.md). -Each integration is designed to work with the .NET Aspire app host, and their configurations are injected automatically by [referencing named resources](../fundamentals/app-host-overview.md#reference-resources). In other words, if _Example.ServiceFoo_ references _Example.ServiceBar_, _Example.ServiceFoo_ inherits the integration's required configurations to allow them to communicate with each other automatically. +## Modeled as resources -For example, consider the following code using the .NET Aspire Service Bus integration: +Aspire makes it easy to define everything your app needs—frontends, APIs, databases, and more—using the unified app host model. Just describe your resources in code, and Aspire handles the connections for you. Resources can include: -```csharp -builder.AddAzureServiceBusClient("servicebus"); -``` +- AI services +- Caches +- Containers +- Databases +- Executables +- Frameworks +- Messaging services +- Projects +- Storage -The method handles the following concerns: +One resource can depend on another, and Aspire automatically wires them together. This means you can focus on building your app without worrying about the underlying infrastructure. -- Registers a as a singleton in the DI container for connecting to Azure Service Bus. -- Applies configurations either inline through code or through configuration. -- Enables corresponding health checks, logging, and telemetry specific to the Azure Service Bus usage. +Under the hood, every integration is either a container or executable, meaning you can add any container image, codebase, script, or cloud resource to your app host. Creating reusable Aspire integrations is just like creating a reusable UI component. It can be as simple or complex as you need, and is fully shareable. -A full list of available integrations is detailed on the [.NET Aspire integrations](../fundamentals/integrations-overview.md) overview page. +For more information, see [Aspire integrations](../fundamentals/integrations-overview.md). -## Project templates and tooling +## Reusable app topology -.NET Aspire provides a set of project templates and tooling experiences for Visual Studio, Visual Studio Code, and the [.NET CLI](/dotnet/core/tools/). These templates are designed to help you create and interact with .NET Aspire projects, or add .NET Aspire into your existing codebase. The templates include a set of opinionated defaults to help you get started quickly - for example, it has boilerplate code for turning on health checks and logging in .NET apps. These defaults are fully customizable, so you can edit and adapt them to suit your needs. +When you compose your distributed app in Aspire's app host, you're not just defining services for local development and orchestration—you're also setting up the foundation for deployment. The same composition you use to run and debug locally is leveraged when you publish your app, ensuring consistency from development through to production. Likewise, Aspire doesn't get in the way of your existing deployment workflows. -.NET Aspire templates also include boilerplate extension methods that handle common service configurations for you: - -```csharp -builder.AddServiceDefaults(); -``` +Continuing from the three-tier architecture example, you can deploy the same app topology to various environments, whether it's a local machine, a cloud provider, or your own servers. Consider the following table that illustrates how the same resources can be deployed across different platforms: -For more information on what `AddServiceDefaults` does, see [.NET Aspire service defaults](../fundamentals/service-defaults.md). +| Resource | Local development | Azure | AWS | +|----------|-------------------|-------|-----| +| Frontend | `npm run` | Azure Container Apps | ECS or App Runner | +| API Service | `dotnet run` | Azure Container Apps | ECS or Lambda | +| Database | Docker container | Azure Database for PostgreSQL | RDS or Aurora | -When added to your _:::no-loc text="Program.cs":::_ file, the preceding code handles the following concerns: +Aspire's deployment capabilities are flexible and extensible, allowing you to adapt to your preferred infrastructure. Aspire doesn't get in the way of your existing deployment workflows, so you can continue using your favorite tools and services. -- **OpenTelemetry**: Sets up formatted logging, runtime metrics, built-in meters, and tracing for ASP.NET Core, gRPC, and HTTP. For more information, see [.NET Aspire telemetry](../fundamentals/telemetry.md). -- **Default health checks**: Adds default health check endpoints that tools can query to monitor your app. For more information, see [.NET app health checks in C#](/dotnet/core/diagnostics/diagnostic-health-checks). -- **Service discovery**: Enables [service discovery](../service-discovery/overview.md) for the app and configures accordingly. +For more information, see [Deploy Aspire apps](../deployment/overview.md). ## Next steps > [!div class="nextstepaction"] -> [Quickstart: Build your first .NET Aspire project](build-your-first-aspire-app.md) +> [Quickstart: Build your first Aspire project](build-your-first-aspire-app.md) From b51b473b6494073bd61617e576368266ed029051 Mon Sep 17 00:00:00 2001 From: David Pine Date: Thu, 26 Jun 2025 14:22:41 -0500 Subject: [PATCH 2/4] A few more tweaks --- docs/get-started/aspire-overview.md | 68 ++++++++++++++++++++--------- 1 file changed, 47 insertions(+), 21 deletions(-) diff --git a/docs/get-started/aspire-overview.md b/docs/get-started/aspire-overview.md index d7351a867a..e2a874383d 100644 --- a/docs/get-started/aspire-overview.md +++ b/docs/get-started/aspire-overview.md @@ -6,15 +6,21 @@ ms.date: 06/26/2025 # Aspire overview -Aspire streamlines building, running, debugging, and deploying distributed apps. Picture your app as a set of services, databases, and frontends—when they're deployed, they all work together seamlessly, but during development they need to be individually started and connected. With Aspire, you get a unified toolchain that eliminates complex configs and makes local debugging effortless. Launch and debug your entire app with a single command. Ready to deploy? Aspire lets you publish anywhere—Kubernetes, the cloud, or your own servers. It's also fully extensible, so you can integrate your favorite tools and services with ease. +Aspire provides tools, templates, and packages to help you build observable, production-ready distributed apps. Delivered through NuGet packages, Aspire simplifies the development experience by streamlining the management of your app's configuration and interconnections. With Aspire, you get a unified toolchain that makes local debugging effortless—launch and debug your entire app with a single command. Ready to deploy? Aspire lets you publish anywhere—Kubernetes, the cloud, or your own servers—using the same app composition you use for development. + +Aspire is designed for flexibility, allowing you to replace or extend parts with your preferred tools and workflows. Key capabilities include: + +- **App host orchestration**: Define your app's services, dependencies, and configuration in code +- **Rich integrations**: NuGet packages for popular services with standardized interfaces +- **Consistent tooling**: Project templates and experiences for Visual Studio, VS Code, and the CLI For the official support information, see the [Aspire Support Policy](https://dotnet.microsoft.com/platform/support/policy/aspire). ## The app host -Aspire's app host is where you define your app's services and dependencies in code—no complex configs required. Easily map out your architecture and let Aspire handle the local orchestration, so you can focus on building features. +Aspire's app host is where you define your app's services and dependencies in code—no complex configuration files required. The app host provides orchestration for your local development environment by simplifying the management of service discovery, environment variables, and container configurations. -A simple example might represent a common three-tier architecture with a frontend that depends on an API, which in turn connects to a database. This could be represented in the app host as shown in the following code: +Picture a common three-tier architecture: a frontend that depends on an API, which connects to a database. In Aspire, this topology is represented in the app host as shown in the following code: ```csharp var builder = DistributedApplication.CreateBuilder(args); @@ -24,7 +30,7 @@ var postgres = builder.AddPostgres("db") .AddDatabase("appdata") .WithDataVolume(); -// Add API service and reference the database +// Add API service and reference dependencies var api = builder.AddProject("api") .WithReference(postgres) .WaitFor(postgres); @@ -36,16 +42,23 @@ var frontend = builder.AddProject("frontend") builder.Build().Run(); ``` -Regardless of the language you choose, Aspire provides a consistent way to define your app's architecture. You can easily add services, set up dependencies, and configure how they interact—all in a straightforward, code-first manner. +The app host assists with the following concerns: + +- **App composition**: Specify the projects, containers, executables, and cloud resources that make up your application +- **Service discovery and connection string management**: Automatically inject the right connection strings and network configurations + +It's important to note that Aspire's orchestration focuses on enhancing the _local development_ experience. It's not intended to replace production systems like Kubernetes, but rather provides abstractions that eliminate low-level implementation details during development. For more information, see [Aspire orchestration overview](../fundamentals/app-host-overview.md). -## Modeled as resources +## Aspire integrations + +Aspire makes it easy to define everything your app needs using integrations—NuGet packages designed to simplify connections to popular services and platforms. Each integration handles cloud resource setup and provides standardized patterns for health checks, telemetry, and configuration. -Aspire makes it easy to define everything your app needs—frontends, APIs, databases, and more—using the unified app host model. Just describe your resources in code, and Aspire handles the connections for you. Resources can include: +Resources you can integrate include: - AI services -- Caches +- Caches - Containers - Databases - Executables @@ -54,27 +67,40 @@ Aspire makes it easy to define everything your app needs—frontends, APIs, data - Projects - Storage -One resource can depend on another, and Aspire automatically wires them together. This means you can focus on building your app without worrying about the underlying infrastructure. +Integrations are two-fold: "hosting" integrations represent the service you're connecting to, while "client" integrations represent the consumer of that service. + +> [!TIP] +> Under the hood, every [integration](../fundamentals/integrations-overview.md) is either a container or executable, meaning you can add any container image, codebase, script, or cloud resource to your app host. Creating reusable Aspire integrations is just like creating a reusable UI component. -Under the hood, every integration is either a container or executable, meaning you can add any container image, codebase, script, or cloud resource to your app host. Creating reusable Aspire integrations is just like creating a reusable UI component. It can be as simple or complex as you need, and is fully shareable. +## From development to deployment + +When you compose your distributed app in Aspire's app host, you're not just defining services for local development—you're setting up the foundation for deployment. The same composition you use to run and debug locally becomes the blueprint for production deployment, ensuring consistency from development through to production. + +Aspire provides project templates and tooling experiences for your favorite development environments. These [templates include opinionated defaults](../fundamentals/aspire-sdk-templates.md) with boilerplate code for health checks, logging, and telemetry. The templates also include service defaults that handle common configurations: + +```csharp +builder.AddServiceDefaults(); +``` -For more information, see [Aspire integrations](../fundamentals/integrations-overview.md). +When added to your C# code, this method configures: -## Reusable app topology +- **OpenTelemetry**: Formatted logging, runtime metrics, and tracing for ASPCore, gRPC, and HTTP +- **Health checks**: Default endpoints that tools can query to monitor your app +- **Service discovery**: Enables service discovery and configures accordingly -When you compose your distributed app in Aspire's app host, you're not just defining services for local development and orchestration—you're also setting up the foundation for deployment. The same composition you use to run and debug locally is leveraged when you publish your app, ensuring consistency from development through to production. Likewise, Aspire doesn't get in the way of your existing deployment workflows. +For more information, see [Aspire service defaults](../fundamentals/service-defaults.md). -Continuing from the three-tier architecture example, you can deploy the same app topology to various environments, whether it's a local machine, a cloud provider, or your own servers. Consider the following table that illustrates how the same resources can be deployed across different platforms: +Consider how the three-tier architecture example can be deployed across different environments: -| Resource | Local development | Azure | AWS | -|----------|-------------------|-------|-----| -| Frontend | `npm run` | Azure Container Apps | ECS or App Runner | -| API Service | `dotnet run` | Azure Container Apps | ECS or Lambda | -| Database | Docker container | Azure Database for PostgreSQL | RDS or Aurora | +| **Resource** | **Local development** | **Azure** | **AWS** | +|----------|-------------------|-------|-----|---------| +| Frontend | `npm run` | Azure Container Apps | AWS ECS or AWS App Runner | +| API service | `dotnet run` | Azure Container Apps | AWS ECS or AWS Lambda | +| Database | `docker.io/library/postgres` | Azure Database for PostgreSQL | AWS RDS or AWS Aurora | -Aspire's deployment capabilities are flexible and extensible, allowing you to adapt to your preferred infrastructure. Aspire doesn't get in the way of your existing deployment workflows, so you can continue using your favorite tools and services. +Aspire's deployment capabilities are flexible and don't interfere with your existing workflows. You can continue using your preferred tools and services while benefiting from the consistent app topology defined in your app host. -For more information, see [Deploy Aspire apps](../deployment/overview.md). +For more information, see [Deploy Aspire apps](../deployment/overview.md) and [Aspire service defaults](../fundamentals/service-defaults.md). ## Next steps From 8d6bc92cbd19ea908fa82b8373fa17ae4c37cbc8 Mon Sep 17 00:00:00 2001 From: David Pine Date: Fri, 18 Jul 2025 11:04:49 -0500 Subject: [PATCH 3/4] A bit more clean up --- docs/get-started/aspire-overview.md | 47 +++++++++++++++-------------- 1 file changed, 25 insertions(+), 22 deletions(-) diff --git a/docs/get-started/aspire-overview.md b/docs/get-started/aspire-overview.md index e2a874383d..c4d64c58c1 100644 --- a/docs/get-started/aspire-overview.md +++ b/docs/get-started/aspire-overview.md @@ -1,18 +1,18 @@ --- title: Aspire overview description: Learn about Aspire, an application stack designed to improve the experience of building distributed applications. -ms.date: 06/26/2025 +ms.date: 07/18/2025 --- # Aspire overview -Aspire provides tools, templates, and packages to help you build observable, production-ready distributed apps. Delivered through NuGet packages, Aspire simplifies the development experience by streamlining the management of your app's configuration and interconnections. With Aspire, you get a unified toolchain that makes local debugging effortless—launch and debug your entire app with a single command. Ready to deploy? Aspire lets you publish anywhere—Kubernetes, the cloud, or your own servers—using the same app composition you use for development. +Aspire provides tools, templates, and packages to help you build observable, production-ready distributed apps. Delivered through packages, Aspire simplifies the development experience by streamlining the management of your app's configuration and interconnections. With Aspire, you get a unified toolchain that makes local debugging effortless—launch and debug your entire app with a single command. Ready to deploy? Aspire lets you publish anywhere—Kubernetes, the cloud, or your own servers—using the same app composition you use for development. Aspire is designed for flexibility, allowing you to replace or extend parts with your preferred tools and workflows. Key capabilities include: -- **App host orchestration**: Define your app's services, dependencies, and configuration in code -- **Rich integrations**: NuGet packages for popular services with standardized interfaces -- **Consistent tooling**: Project templates and experiences for Visual Studio, VS Code, and the CLI +- **App host orchestration**: Define your app's services, dependencies, and configuration in code. +- **Rich integrations**: NuGet packages for popular services with standardized interfaces. +- **Consistent tooling**: Project templates and experiences for Visual Studio, VS Code, and the CLI. For the official support information, see the [Aspire Support Policy](https://dotnet.microsoft.com/platform/support/policy/aspire). @@ -57,15 +57,15 @@ Aspire makes it easy to define everything your app needs using integrations—Nu Resources you can integrate include: -- AI services -- Caches -- Containers -- Databases -- Executables -- Frameworks -- Messaging services -- Projects -- Storage +- **AI Services**: Large Language Models, AI endpoints, and cognitive services. +- **Caches**: Redis, in-memory caches, and distributed caching solutions. +- **Containers**: Docker containers for databases, message brokers, and other services. +- **Databases**: SQL Server, PostgreSQL, MySQL, MongoDB, and other data stores. +- **Executables**: Console applications, scripts, and background services. +- **Frameworks**: Web applications, APIs, and microservices built with various frameworks. +- **Messaging Services**: Service Bus, RabbitMQ, Kafka, and other messaging systems. +- **Projects**: .NET projects, Node.js applications, Python services, and more. +- **Storage**: Blob storage, file systems, and cloud storage services. Integrations are two-fold: "hosting" integrations represent the service you're connecting to, while "client" integrations represent the consumer of that service. @@ -84,9 +84,9 @@ builder.AddServiceDefaults(); When added to your C# code, this method configures: -- **OpenTelemetry**: Formatted logging, runtime metrics, and tracing for ASPCore, gRPC, and HTTP -- **Health checks**: Default endpoints that tools can query to monitor your app -- **Service discovery**: Enables service discovery and configures accordingly +- **OpenTelemetry**: Formatted logging, runtime metrics, and tracing for ASPCore, gRPC, and HTTP. +- **Health checks**: Default endpoints that tools can query to monitor your app. +- **Service discovery**: Enables service discovery and configures accordingly. For more information, see [Aspire service defaults](../fundamentals/service-defaults.md). @@ -94,15 +94,18 @@ Consider how the three-tier architecture example can be deployed across differen | **Resource** | **Local development** | **Azure** | **AWS** | |----------|-------------------|-------|-----|---------| -| Frontend | `npm run` | Azure Container Apps | AWS ECS or AWS App Runner | -| API service | `dotnet run` | Azure Container Apps | AWS ECS or AWS Lambda | -| Database | `docker.io/library/postgres` | Azure Database for PostgreSQL | AWS RDS or AWS Aurora | +| Frontend | `npm run` | Azure Container Apps | Amazon Elastic Container Service | +| API service | `dotnet run` | Azure Container Apps | AWS Lambda | +| Database | `docker.io/library/postgres` | Azure Database for PostgreSQL | Amazon Relational Database Service | + +> [!TIP] +> These are just a few examples of how you can deploy Aspire apps. Aspire's deployment capabilities are flexible and don't interfere with your existing workflows. You can continue using your preferred tools and services while benefiting from the consistent app topology defined in your app host. -For more information, see [Deploy Aspire apps](../deployment/overview.md) and [Aspire service defaults](../fundamentals/service-defaults.md). +For more information, see [Deploy Aspire apps](../deployment/overview.md). ## Next steps > [!div class="nextstepaction"] -> [Quickstart: Build your first Aspire project](build-your-first-aspire-app.md) +> [Build your first Aspire solution](build-your-first-aspire-app.md) From 0bf1e6d4a0441848bfca46ac3ad50ad4d93d5691 Mon Sep 17 00:00:00 2001 From: David Pine Date: Fri, 18 Jul 2025 11:09:12 -0500 Subject: [PATCH 4/4] Clarify terminology in Aspire overview by emphasizing "hosting" integrations in the documentation. --- docs/get-started/aspire-overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/get-started/aspire-overview.md b/docs/get-started/aspire-overview.md index c4d64c58c1..69034189f3 100644 --- a/docs/get-started/aspire-overview.md +++ b/docs/get-started/aspire-overview.md @@ -70,7 +70,7 @@ Resources you can integrate include: Integrations are two-fold: "hosting" integrations represent the service you're connecting to, while "client" integrations represent the consumer of that service. > [!TIP] -> Under the hood, every [integration](../fundamentals/integrations-overview.md) is either a container or executable, meaning you can add any container image, codebase, script, or cloud resource to your app host. Creating reusable Aspire integrations is just like creating a reusable UI component. +> Under the hood, every _hosting_ [integration](../fundamentals/integrations-overview.md) is either a container or executable, meaning you can add any container image, codebase, script, or cloud resource to your app host. Creating reusable Aspire integrations is just like creating a reusable UI component. ## From development to deployment