Introducción

Aspire en .NET es un conjunto de herramientas e integraciones para describir, ejecutar, observar y preparar el despliegue de aplicaciones distribuidas. Permite declarar la relación entre una API, una interfaz web, una caché y otros recursos en un modelo de aplicación, en lugar de depender de una secuencia informal de comandos y variables copiadas entre terminales. El beneficio más inmediato aparece en el desarrollo: iniciar el conjunto e investigar una llamada entre servicios se vuelve más predecible.

Eso no significa que toda aplicación deba convertirse en un conjunto de microservicios. Puedo usar Aspire para una API acompañada de Redis y mantener el dominio en un monolito bien organizado. Tampoco significa que un dashboard local resuelva la operación en producción: identidad, disponibilidad, persistencia, retención de telemetría y recuperación siguen exigiendo decisiones propias. Aspire reduce el trabajo repetitivo de composición; no elimina la arquitectura.

El problema que interesa aquí es concreto. Una persona conoce el puerto de la API, otra sabe qué contenedor debe iniciarse primero y una tercera mantiene la connection string correcta en un archivo que nadie documentó. Cuando el entorno finalmente funciona, investigar una solicitud exige combinar logs de procesos distintos. Cuantas más dependencias participan en ese camino, mayor es el costo de reproducir un fallo y de preparar a alguien nuevo para contribuir.

En este artículo, separo tres piezas que suelen aparecer juntas: AppHost, ServiceDefaults y el dashboard. Después recorro el starter oficial para mostrar dónde encaja cada una y cómo verificar el resultado. El foco es entender el modelo y hacer una primera adopción consciente, no presentar un catálogo de integraciones ni prometer una plataforma de producción lista. Usaré C# y .NET 10 como referencia, pero la documentación actual llama al producto Aspire y también contempla aplicaciones con otros lenguajes.

Requisitos previos

Para seguir el ejemplo, considera:

  • .NET SDK 10 instalado en el entorno donde se ejecutará el starter. El runtime por sí solo no crea ni compila los proyectos.
  • SDK y plantillas compatibles. El recorrido fija las plantillas en Aspire 13.6.4, sin afirmar que esa será la versión más reciente cuando leas el artículo.
  • Un runtime de contenedores compatible, como Docker, si habilitas Redis u otra dependencia ejecutada en contenedor. Esto no exige contenerizar todos los proyectos .NET locales.
  • HTTPS de desarrollo configurado. En Linux, la confianza en el certificado también depende de la distribución y del navegador; no desactives la validación de TLS para evitar el problema.
  • Acceso a las fuentes de paquetes e imágenes que usa el starter. Un entorno corporativo puede exigir proxy, espejo de registry y aprobación de dependencias.

Los comandos siguientes están pensados para un entorno de desarrollo aislado. No apuntan a infraestructura existente ni hacen despliegues. Como el starter evoluciona entre versiones, registra el SDK, las plantillas y las opciones elegidas antes de convertir el ejemplo en referencia del equipo.

Qué resuelve Aspire y qué sigue siendo arquitectura

Una aplicación distribuida no es solo una lista de ejecutables. Tiene un grafo de dependencias: la interfaz llama a una API, la API accede a una base de datos, un Worker consume mensajes y algunos de esos caminos necesitan producir telemetría correlacionada. Sin una descripción compartida, parte de ese grafo queda dispersa entre documentación, configuración y conocimiento personal.

Aspire ofrece una forma de hacer explícitas esas relaciones. El modelo puede identificar servicios por nombres lógicos, asociar dependencias y proporcionar configuraciones de conexión. Las integraciones también pueden facilitar el registro de clientes, las comprobaciones de salud y la instrumentación. La ganancia no está en ocultar que Redis existe, sino en evitar que cada desarrollador reconstruya su configuración por ensayo y error.

Distinguiría la composición técnica de la descomposición de negocio. Definir que una API usa una caché no explica dónde termina un contexto de dominio, si dos operaciones necesitan una transacción o cómo un consumidor evita procesar un mensaje dos veces. Esas decisiones siguen perteneciendo a la aplicación. El Transactional Outbox Pattern, por ejemplo, trata un problema de consistencia que no desaparece cuando los procesos pasan a iniciarse desde el mismo AppHost.

Por eso, no adoptaría Aspire como justificación para fragmentar un sistema. Una aplicación modular acompañada de dependencias externas puede aprovechar la herramienta sin aumentar la cantidad de servicios de negocio. El criterio útil es otro: ¿cuánto trabajo repetitivo tiene el equipo para componer el entorno e investigar el comportamiento entre recursos? Si la respuesta es pequeña, quizá la adopción pueda esperar. Si es recurrente y costosa, existe un problema adecuado para resolver.

AppHost describe los recursos y sus relaciones

El AppHost es el punto donde se compone el modelo de aplicación. En el camino de C#, usa las APIs de hosting de Aspire para registrar proyectos, contenedores y recursos soportados por las integraciones. Esa definición permite relacionar dependencias por nombre, sin dispersar un puerto fijo o una connection string local por todos los proyectos.

Un AppHost que incluye interfaz y API puede tener una configuración como esta. Los tipos en Projects se generan a partir de las referencias de proyecto del AppHost; no son namespaces que debas crear manualmente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
var builder = DistributedApplication.CreateBuilder(args);

var api = builder.AddProject<Projects.LojaAspire_ApiService>("apiservice")
  .WithHttpHealthCheck("/health");

// La referencia de configuración y la dependencia de inicio son explícitas.
builder.AddProject<Projects.LojaAspire_Web>("webfrontend")
  .WithExternalHttpEndpoints()
  .WithHttpHealthCheck("/health")
    .WithReference(api)
    .WaitFor(api);

builder.Build().Run();

ℹ️ Información: El fragmento adapta la composición del starter oficial. El código completo lo genera la plantilla aspire-starter; los ejemplos mantenidos por el equipo están en el repositorio oficial aspire-samples.

Hay una distinción importante: WithReference no significa esperar. La referencia pone a disposición la configuración necesaria para consumir el recurso, según su tipo. WaitFor expresa una dependencia de inicio y puede considerar las comprobaciones de salud configuradas. Si el recurso no tiene una comprobación representativa, esperarlo no demuestra que todas sus operaciones estén disponibles.

Tampoco existe una recuperación permanente implícita. Una base de datos puede quedar indisponible después de que la API se inició; en ese momento, la aplicación necesita manejar timeouts, cancelación y fallos transitorios. El modelo ayuda a iniciar el entorno de forma coherente, pero no convierte el éxito del arranque en garantía de disponibilidad durante toda la ejecución. Separar esas responsabilidades evita una falsa sensación de protección operativa.

El AppHost de Aspire referencia web, API y Redis; los servicios envían telemetría al dashboard

ServiceDefaults configura los servicios, no el dominio

ServiceDefaults suele ser un proyecto compartido creado por la plantilla. Concentra extensiones para aplicar configuraciones comunes a los servicios .NET, como instrumentación OpenTelemetry, health checks, descubrimiento de servicios y resiliencia de clientes HTTP. El nombre describe una convención útil, no un servidor central que todas las solicitudes deban atravesar.

El efecto depende de que cada aplicación adopte esas extensiones. En el starter, busca llamadas como builder.AddServiceDefaults() durante la configuración y app.MapDefaultEndpoints() en el mapeo de endpoints. Mantener el proyecto dentro de la solución no habilita automáticamente todo en los demás proyectos. Ese detalle es relevante al incorporar Aspire a una aplicación existente: la composición del entorno y la configuración interna de los servicios son cambios relacionados, pero distintos.

Mantendría este proyecto pequeño. La configuración de telemetría y las políticas técnicas comunes caben en él; las reglas de aprobación de pedidos, los contratos específicos de un módulo y el acceso a datos de negocio, no. De lo contrario, un facilitador de infraestructura se convierte en una biblioteca de dependencia obligatoria para todo el dominio, lo que aumenta el costo de cambiar servicios de forma independiente.

También revisaría los valores predeterminados antes de adoptarlos. La configuración de resiliencia de un cliente HTTP debe respetar la semántica de la operación. Repetir una lectura no tiene el mismo riesgo que repetir un cobro o un comando sin protección contra duplicados. Configura la política adecuada, usa idempotencia cuando sea necesaria y propaga la cancelación.

El mismo cuidado vale para la salud. En el ServiceDefaults predeterminado, los endpoints de health check se mapean en desarrollo. Si necesitas probes en producción, configura esa exposición de forma consciente, con el alcance y las protecciones adecuados. Un endpoint técnico no debe filtrar detalles internos solo porque ya estaba disponible en el entorno local.

El dashboard y OpenTelemetry hacen investigable el flujo

El dashboard de Aspire presenta recursos e información de observabilidad, como los logs, métricas y trazas que proporciona la instrumentación. Su utilidad aparece cuando puedo partir del síntoma visible en la interfaz y seguir el camino hasta la API, observando el comportamiento de cada etapa en lugar de buscar frases sueltas en terminales distintas.

Esa experiencia depende de la instrumentación y del contexto. Un servicio necesita producir las señales, y una llamada entre servicios necesita propagar los identificadores necesarios para que los spans aparezcan relacionados. Usar una biblioteca no instrumentada o interrumpir la propagación en una cola puede dejar huecos. El dashboard ayuda a ver lo que se emitió; no inventa lo que la aplicación nunca registró.

También separaría la observabilidad técnica de la telemetría de negocio. Una solicitud HTTP exitosa y rápida no demuestra, por sí sola, que un pedido se facturó correctamente. Para eso, todavía necesito definir eventos, métricas y atributos que representen el comportamiento relevante. Al elegir esos atributos, evito datos personales y dimensiones con cardinalidad descontrolada, como usar un identificador diferente como label de cada métrica.

El artículo sobre logging estructurado en .NET profundiza en el contexto y las propiedades de los logs. Aquí, el punto complementario es la correlación entre componentes y la composición del entorno. En producción, la retención, el control de acceso, la exportación, el muestreo y las alertas exigen una solución operativa definida. OpenTelemetry facilita instrumentar y exportar señales; no proporciona, por sí solo, todo el almacenamiento ni el proceso de respuesta a incidentes.

⚠️ Atención: No expongas públicamente el dashboard de desarrollo como atajo de monitoreo. Los logs y las trazas pueden revelar URLs, nombres de recursos e información sensible. Revisa la autenticación, la red y el contenido de la telemetría antes de poner a disposición cualquier interfaz operativa.

Las integraciones y el descubrimiento de servicios no eliminan los contratos

Aspire diferencia la configuración del recurso en el AppHost de la configuración del cliente en la aplicación. En el caso de Redis, una integración de hosting permite agregar el recurso al modelo. En la aplicación consumidora, una integración de cliente puede registrar la implementación que usa el código, incluida su configuración y las funciones técnicas disponibles.

Esa separación evita una interpretación frecuente: agregar Redis al AppHost no hace que la API empiece a usar caché. El servicio todavía necesita referenciar el recurso y registrar un cliente compatible. El código de negocio también necesita decidir qué almacenar, cómo componer las claves, qué expiración aplicar y qué hacer cuando la caché falla. Aspire ayuda con la conexión; no elige la política de caché.

Los nombres deben corresponder. Si el recurso se llama cache, la configuración del cliente debe buscar esa conexión, en lugar de suponer que encontrará cualquier Redis disponible. Para las llamadas HTTP, el descubrimiento permite trabajar con nombres lógicos y resolver los endpoints configurados. Eso no equivale a crear DNS público, configurar un API Gateway ni proteger una API con autorización.

Hay además una diferencia entre tener una conexión y usar el recurso con seguridad. Un Redis accesible puede seguir sufriendo por valores enormes, claves sin expiración o disputa entre aplicaciones. El artículo Redis: las big keys destruyen el rendimiento compartido trata justamente ese riesgo. Mantendría esas decisiones explícitas incluso después de simplificar la creación del entorno.

Para una primera adopción, empezaría con un único camino: la interfaz llamando a la API. Después agregaría una dependencia externa y verificaría qué cambió en la configuración, los health checks y la telemetría. Ese crecimiento incremental deja visible lo que cada integración realmente entrega.

Ejemplo Práctico

Usaré el starter oficial, que ya proporciona una interfaz web, una API, el AppHost y el proyecto de valores predeterminados de servicio. La idea es comprender una composición funcional antes de adaptar el modelo a un repositorio existente. No es necesario copiar clases de negocio ni crear un proyecto de ejemplo independiente para reproducir estos pasos.

En una carpeta de trabajo, instala la versión de referencia de las plantillas y crea la solución:

1
2
3
4
5
# Fija la versión para que el recorrido no dependa de la plantilla más reciente.
dotnet new install [email protected]

# Crea el starter con proyectos orientados a .NET 10.
dotnet new aspire-starter --name LojaAspire --output LojaAspire --framework net10.0

Lee las opciones que presenta la plantilla y registra las que selecciones. El núcleo de este ejemplo no depende de habilitar Redis. Si eliges una opción de caché basada en contenedor, el runtime de contenedores debe estar disponible antes de la ejecución. Mantén también las versiones de los proyectos generados como conjunto, en lugar de actualizar solo una integración sin comprobar la compatibilidad.

En la estructura creada, identifica estas responsabilidades:

ProyectoQué comprobar
LojaAspire.AppHostRecursos registrados y referencias entre interfaz y API
LojaAspire.ServiceDefaultsExtensiones de telemetría, salud, descubrimiento y resiliencia
LojaAspire.ApiServiceEndpoints de la aplicación y adopción de los valores comunes
LojaAspire.WebCliente HTTP que accede a la API por el nombre lógico

Antes de iniciar, verifica el certificado HTTPS de desarrollo. El comando de confianza siguiente se aplica al entorno local y puede depender de configuración adicional en Linux; no es una orientación para modificar certificados de producción:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Configura la confianza en el certificado en el entorno de desarrollo.
dotnet dev-certs https --trust

# Restaura y compila la solución generada.
dotnet restore LojaAspire
dotnet build LojaAspire --no-restore

# Revisa también las dependencias transitivas antes de adoptar el ejemplo.
dotnet list LojaAspire package --vulnerable --include-transitive

# Inicia la composición desde el AppHost, no desde cuatro terminales separadas.
dotnet run --project LojaAspire/LojaAspire.AppHost

En la validación de este recorrido, el starter 13.6.4 se generó con .NET SDK 10.0.402 y compiló con cero errores y cero advertencias. La auditoría con dependencias transitivas no identificó paquetes vulnerables conocidos en ese momento; ese resultado no sustituye nuevas comprobaciones cuando se actualicen las bases de avisos de seguridad.

Usa la URL del dashboard que aparece en la consola, sin suponer un puerto fijo ni eliminar el mecanismo de acceso generado. Abre la interfaz web desde la lista de recursos y activa la página que consulta la API. En el starter, la demostración suele usar datos de previsión del tiempo; lo importante es observar una solicitud real entre los proyectos, no el dominio elegido para el ejemplo.

Mi verificación tendría cuatro partes: los recursos esperados aparecen en ejecución; la interfaz puede consultar la API; la llamada produce señales de telemetría; y los logs permiten distinguir el origen de un fallo. Si no hay traza, verificaría la instrumentación, la exportación y la propagación, en lugar de concluir de inmediato que la llamada no ocurrió.

Después, en una prueba local controlada, detén solo la API del ejemplo y repite la consulta. Observa el error, los límites de espera y la recuperación cuando el servicio vuelva. No lo hagas en un entorno compartido. Este ejercicio muestra una frontera importante: una dependencia configurada no significa una dependencia siempre disponible. Antes de usar el modelo en un producto, el comportamiento ante fallos debe ser tan comprensible como el camino de éxito.

Aspire, Docker Compose y Kubernetes cumplen papeles distintos

Comparar Aspire con Docker Compose o Kubernetes como si fueran alternativas perfectamente equivalentes suele producir una mala decisión. Pueden participar en el mismo flujo, pero actúan en niveles distintos. Aspire ofrece un modelo de aplicación y herramientas de desarrollo, observabilidad y despliegue; Compose describe y ejecuta servicios en contenedores; Kubernetes opera workloads en un clúster con mecanismos propios de reconciliación y disponibilidad.

NecesidadDónde empezaría a evaluar
Desarrollar servicios y dependencias con referencias explícitas y telemetría integradaAspire
Ejecutar un conjunto pequeño de servicios ya contenerizados, con configuración conocida por el equipoDocker Compose
Operar workloads en un clúster con políticas, reconciliación y escalabilidadKubernetes y su plataforma operativa
Introducir un modelo de aplicación y producir artefactos para un destino soportadoAspire con la integración de despliegue apropiada

El AppHost es especialmente relevante para la composición del desarrollo, pero la afirmación de que Aspire sirve solo para iniciar procesos locales también está incompleta. Las versiones actuales tienen funciones de publicación y despliegue, con integraciones para destinos como Docker Compose y Kubernetes. La madurez y los requisitos de cada integración deben comprobarse en la versión adoptada; las funciones en preview no deben tratarse como contratos estables sin evaluación.

Eso no convierte al AppHost en el orquestador permanente de producción. Incluso cuando un flujo genera o aplica artefactos, alguien necesita definir imágenes, secretos, almacenamiento, red, probes, políticas, copias de seguridad y recuperación. El destino sigue teniendo su propio modelo operativo. Evaluaría tanto el resultado generado como el proceso de actualización y rollback.

Para un equipo que ya opera bien con Compose, la adopción debe demostrar una ganancia concreta, no solo cambiar YAML por C#. Para una plataforma Kubernetes existente, empezaría por la experiencia de desarrollo y la integración con la entrega actual, evitando un segundo camino de publicación sin un responsable claro. Aspire puede reducir la fricción; un cambio de herramienta todavía debe respetar lo que ya funciona.

Consejos y Buenas Prácticas

  • Empieza por el grafo útil más pequeño. Una interfaz y una API ya permiten observar el descubrimiento y la correlación. Agrega base de datos, caché o mensajería solo cuando la aplicación los necesite, no para llenar el dashboard.
  • Versiona la configuración que reproduce el entorno. Registra el SDK, las plantillas, los paquetes y las opciones usadas. Actualiza el conjunto con revisión y pruebas, sin tratar la palabra “latest” como estrategia de compatibilidad.
  • Diferencia referencia, disponibilidad y resiliencia. WithReference, WaitFor y las políticas de fallo resuelven problemas distintos. Verifica el comportamiento después del inicio, incluidas la indisponibilidad, la cancelación y los límites de tiempo.
  • Revisa lo que entra en la telemetría. Un entorno observable no necesita registrar tokens, payloads sensibles ni datos personales. Define atributos útiles, controla la cardinalidad y trata el dashboard como una interfaz con requisitos de seguridad.
  • Mantén ServiceDefaults fuera del dominio. Comparte valores técnicos pequeños y explícitos. Evita una biblioteca central que obligue a todos los servicios a importar contratos y reglas de negocio sin necesidad.
  • Planifica la persistencia y los secretos por separado. Una base de datos creada para desarrollo no es una estrategia de datos de producción. Define la retención local, la restauración y el tratamiento de credenciales antes de usar información real.
  • Prueba un fallo real en el entorno aislado. Haz una llamada, observa la traza y detén una dependencia del ejemplo con un alcance conocido. El aprendizaje está en comprender la reacción de la aplicación, no solo en obtener indicadores en verde.

Resumen Objetivo

  • Aspire proporciona herramientas e integraciones para componer, ejecutar, observar y preparar el despliegue de aplicaciones distribuidas; usarlo no exige convertir un monolito en microservicios.
  • AppHost describe recursos y relaciones. WithReference proporciona configuración de referencia; WaitFor expresa una dependencia de inicio y no garantiza disponibilidad permanente.
  • ServiceDefaults es un proyecto de valores técnicos adoptados por los servicios, con configuraciones como OpenTelemetry, descubrimiento, health checks y resiliencia HTTP.
  • El dashboard de Aspire presenta las señales emitidas por la aplicación. La correlación depende de la instrumentación y de la propagación de contexto; la retención, las alertas y la seguridad exigen decisiones operativas.
  • Las integraciones de hosting y de cliente tienen responsabilidades distintas: agregar un recurso al modelo no hace que el código de negocio empiece a consumirlo automáticamente.
  • El despliegue con Aspire puede usar integraciones para destinos como Docker Compose y Kubernetes, pero no elimina la configuración de secretos, persistencia, red, disponibilidad y recuperación.
  • Starter de referencia: los comandos del artículo usan Aspire ProjectTemplates 13.6.4 y .NET 10; las versiones y opciones deben registrarse para reproducir el entorno.

Lee También

Referencias