Guida Microsoft Aspire

Guida Microsoft Aspire: Sviluppare Applicazioni Cloud-Native Distribuite con .NET

Indice della Guida Microsoft Aspire

1. Introduzione
2. Storia e Nascita di Microsoft Aspire
3. Cos’è Microsoft Aspire
4. Architettura e Componenti Fondamentali
5. Prerequisiti e Setup dell’Ambiente di Sviluppo
6. Creare la Prima Applicazione Aspire da Zero
7. Integrazioni: Database, Caching, Messaggistica e Storage
8. Service Discovery e Comunicazione tra Servizi
9. Dashboard Aspire e Osservabilità
10. Caso d’Uso Pratico: API RESTful con PostgreSQL e Redis
11. Deployment su Azure Container Apps
12. Deployment su Kubernetes
13. Pro e Contro di Microsoft Aspire
14. Conclusioni: L’Importanza della Formazione Continua

1. Introduzione

Lo sviluppo di applicazioni cloud-native distribuite rappresenta oggi una delle sfide più complesse per i team di sviluppo enterprise. La gestione di microservizi, container, orchestrazione, service discovery, telemetria e resilienza richiede competenze multidisciplinari e una curva di apprendimento significativa. Microsoft Aspire nasce proprio per rispondere a questa complessità, offrendo uno stack tecnologico opinionato che semplifica radicalmente la creazione, l’esecuzione e il deployment di applicazioni distribuite nell’ecosistema .NET.

Questa guida è rivolta a sviluppatori .NET, ingegneri informatici e laureati in informatica, sia junior che senior, che desiderano apprendere come utilizzare Aspire per costruire sistemi scalabili, osservabili e production-ready.

2. Storia e Nascita di Microsoft Aspire

Microsoft Aspire è stato annunciato per la prima volta nel novembre 2023 durante la conferenza .NET Conf, in concomitanza con il lancio di .NET 8. Il progetto rappresenta l’evoluzione naturale di Project Tye, un esperimento della community iniziato nel 2019 per semplificare lo sviluppo di applicazioni distribuite.

La General Availability (GA) di Aspire è stata raggiunta il 21 maggio 2024, con il rilascio di Visual Studio 2022 17.10. Da quel momento, il framework ha visto un’evoluzione costante: la versione 9.1 è stata rilasciata il 25 febbraio 2025 insieme alla prima preview di .NET 10, mentre la versione 13 è stata annunciata l’11 novembre 2025 durante .NET Conf 2025, introducendo supporto esteso per Python, JavaScript e integrazioni AI avanzate.

Il rebranding da “.NET Aspire” ad “Aspire” riflette l’ambizione del progetto di diventare una soluzione poliglotta per lo sviluppo cloud-native, pur mantenendo .NET come piattaforma principale.

3. Cos’è Microsoft Aspire

Aspire è uno stack cloud-native opinionato che semplifica il flusso di sviluppo con controllo code-first, modularità e osservabilità per applicazioni distribuite. È uno strumento di orchestrazione poliglotta per costruire, eseguire, debuggare e deployare applicazioni distribuite.

Caratteristiche Chiave

Opinionato: Microsoft ha preso decisioni architetturali precise su come configurare i vari componenti dello stack tecnologico, pur mantenendo flessibilità per personalizzazioni.

Cloud-Ready: Le applicazioni create sono immediatamente pronte per il deployment in ambienti cloud come Azure, AWS o infrastrutture on-premises.

Osservabile: Include OpenTelemetry integrato per metriche, trace distribuite e logging, fornendo visibilità completa sul comportamento dell’applicazione.

Resiliente: Supporta automaticamente retry, circuit breaker e timeout configurabili per gestire failure in modo elegante.

4. Architettura e Componenti Fondamentali

L’architettura di Aspire si basa su tre pilastri fondamentali:

4.1 AppHost Project

L’AppHost è il progetto orchestratore che definisce il modello applicativo. Qui si configurano tutti i servizi, i container, i database e le dipendenze dell’applicazione distribuita.

var builder = DistributedApplication.CreateBuilder(args);

var postgres = builder.AddPostgres("postgres")
    .WithLifetime(ContainerLifetime.Persistent);

var database = postgres.AddDatabase("catalogdb");

var api = builder.AddProject<Projects.CatalogApi>("catalogapi")
    .WithReference(database);

builder.Build().Run();

4.2 ServiceDefaults

Il progetto ServiceDefaults definisce configurazioni standard riutilizzabili per tutti i servizi:

public static IHostApplicationBuilder AddServiceDefaults(
    this IHostApplicationBuilder builder)
{
    builder.ConfigureOpenTelemetry();
    builder.AddDefaultHealthChecks();
    builder.Services.AddServiceDiscovery();
    
    builder.Services.ConfigureHttpClientDefaults(http =>
    {
        http.AddStandardResilienceHandler();
        http.AddServiceDiscovery();
    });
    
    return builder;
}

4.3 Hosting Integrations

Le hosting integration estendono l’interfaccia IDistributedApplicationBuilder per modellare risorse come database, code di messaggi e servizi cloud.

4.4 Client Integrations

Le client integration configurano librerie client esistenti per connettersi alle hosting integration, gestendo dependency injection, configurazione schema, health check e telemetria.

5. Prerequisiti e Setup dell’Ambiente di Sviluppo – Guida Microsoft Aspire

Requisiti Minimi

• .NET 8 SDK o superiore (.NET 9 o .NET 10 Preview per versioni recenti)
• Visual Studio 2022 17.9+ o Visual Studio Code con C# Dev Kit
• Docker Desktop o Podman per l’esecuzione dei container
• Azure Developer CLI (azd) per il deployment su Azure

Installazione Workload Aspire

# Aggiorna e installa il workload Aspire
dotnet workload update
dotnet workload install aspire

Per Visual Studio 2022, il workload Aspire è incluso automaticamente nel carico di lavoro “ASP.NET and web development” dalla versione 17.10 in poi.

6. Creare la Prima Applicazione Aspire da Zero

Step 1: Creazione del Progetto

# Crea una nuova solution Aspire
dotnet new aspire-starter -n MyFirstAspireApp
cd MyFirstAspireApp

La struttura generata include:

• MyFirstAspireApp.AppHost: Progetto orchestratore
• MyFirstAspireApp.ServiceDefaults: Configurazioni standard
• MyFirstAspireApp.ApiService: Web API di esempio
• MyFirstAspireApp.Web: Frontend Blazor

Step 2: Esecuzione Locale

cd MyFirstAspireApp.AppHost
dotnet run

Il comando avvia automaticamente:

• Tutti i progetti referenziati
• Container Docker necessari
• Aspire Dashboard (generalmente su https://localhost:5001)

Step 3: Esplorazione della Dashboard

La Dashboard Aspire offre visualizzazione in tempo reale di:

• Resources: Tutti i servizi, container e dipendenze
• Logs: Aggregazione dei log di tutti i componenti
• Traces: Trace distribuite con OpenTelemetry
• Metrics: Metriche di performance e utilizzo risorse

7. Integrazioni: Database, Caching, Messaggistica e Storage

Aspire offre un ecosistema ricco di integrazioni pronte all’uso.

7.1 Database

PostgreSQL

// AppHost
var postgres = builder.AddPostgres("postgres")
    .WithPgAdmin()
    .WithLifetime(ContainerLifetime.Persistent);
var db = postgres.AddDatabase("mydb");

var api = builder.AddProject<Projects.Api>("api")
    .WithReference(db);

// Client Project - Program.cs
builder.AddNpgsqlDataSource("mydb");

// Utilizzo via DI
public class ProductRepository
{
    private readonly NpgsqlDataSource _dataSource;
    
    public ProductRepository(NpgsqlDataSource dataSource)
    {
        _dataSource = dataSource;
    }
    
    public async Task<List<Product>> GetAllAsync()
    {
        await using var connection = await _dataSource.OpenConnectionAsync();
        // Query PostgreSQL
    }
}

SQL Server

var sqlServer = builder.AddSqlServer("sql")
    .AddDatabase("catalogdb");

7.2 Caching – Redis

// AppHost
var cache = builder.AddRedis("cache")
    .WithRedisInsight()
    .WithLifetime(ContainerLifetime.Persistent);

builder.AddProject<Projects.Frontend>("frontend")
    .WithReference(cache);

// Client Project
builder.AddRedisOutputCache("cache");

// In Program.cs
app.UseOutputCache();

// In un controller
[OutputCache(Duration = 60)]
public IActionResult GetData()
{
    return Ok(data);
}

7.3 Messaggistica

RabbitMQ

// AppHost
var messaging = builder.AddRabbitMQ("messaging")
    .WithManagementPlugin();

// Client
builder.AddRabbitMQClient("messaging");

Azure Service Bus

var serviceBus = builder.AddAzureServiceBus("messaging");

7.4 Storage

Azure Blob Storage

var storage = builder.AddAzureStorage("storage")
    .RunAsEmulator();
var blobs = storage.AddBlobs("blobs");

8. Service Discovery e Comunicazione tra Servizi

Aspire gestisce automaticamente il service discovery, eliminando la necessità di hard-coded URL.

// AppHost - definizione servizi
var api = builder.AddProject<Projects.CatalogApi>("catalogapi");
var frontend = builder.AddProject<Projects.Frontend>("frontend")
    .WithReference(api);

// Frontend - utilizzo del servizio
public class CatalogService
{
    private readonly HttpClient _httpClient;
    
    public CatalogService(IHttpClientFactory factory)
    {
        // Service discovery automatico tramite nome logico
        _httpClient = factory.CreateClient();
        _httpClient.BaseAddress = new Uri("http://catalogapi");
    }
    
    public async Task<List<Product>> GetProductsAsync()
    {
        return await _httpClient.GetFromJsonAsync<List<Product>>(
            "/api/products");
    }
}

9. Dashboard Aspire e Osservabilità – Guida Microsoft Aspire

La Dashboard Aspire è accessibile automaticamente durante l’esecuzione locale e può essere deployata anche in produzione.

Funzionalità Chiave

• Dependency Graph: Visualizzazione delle relazioni tra servizi
• Structured Logs: Aggregazione intelligente con filtri avanzati
• Distributed Tracing: Trace end-to-end delle richieste
• Metrics: CPU, memoria, richieste HTTP, query database
• Health Status: Stato di salute di ogni componente

10. Caso d’Uso Pratico: API RESTful con PostgreSQL e Redis

Costruiamo un’API per la gestione di un catalogo prodotti con caching Redis.

Step 1: Setup AppHost

var builder = DistributedApplication.CreateBuilder(args);

var postgres = builder.AddPostgres("postgres")
    .WithLifetime(ContainerLifetime.Persistent);
var catalogDb = postgres.AddDatabase("catalogdb");

var redis = builder.AddRedis("cache")
    .WithLifetime(ContainerLifetime.Persistent);

var catalogApi = builder.AddProject<Projects.CatalogApi>("catalogapi")
    .WithReference(catalogDb)
    .WithReference(redis);

builder.Build().Run();

Step 2: API Implementation

// Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.AddServiceDefaults();
builder.AddNpgsqlDataSource("catalogdb");
builder.AddRedisOutputCache("cache");

var app = builder.Build();

app.MapDefaultEndpoints();
app.UseOutputCache();

app.MapGet("/api/products", async (NpgsqlDataSource db) =>
{
    await using var conn = await db.OpenConnectionAsync();
    await using var cmd = conn.CreateCommand();
    cmd.CommandText = "SELECT id, name, price FROM products";
    
    var products = new List<Product>();
    await using var reader = await cmd.ExecuteReaderAsync();
    while (await reader.ReadAsync())
    {
        products.Add(new Product
        {
            Id = reader.GetInt32(0),
            Name = reader.GetString(1),
            Price = reader.GetDecimal(2)
        });
    }
    return Results.Ok(products);
})
.CacheOutput(p => p.Expire(TimeSpan.FromMinutes(5)));

app.Run();

record Product(int Id, string Name, decimal Price);

Step 3: Test Locale

dotnet run --project CatalogApi.AppHost

La prima chiamata a /api/products interroga PostgreSQL; le successive per 5 minuti utilizzano Redis cache.

11. Deployment su Azure Container Apps – Guida Microsoft Aspire

Azure Container Apps (ACA) è una piattaforma fully-managed per eseguire microservizi e applicazioni containerizzate su una piattaforma serverless.

Step-by-Step Deployment

# Login ad Azure
az login

# Inizializza Azure Developer CLI
azd init

# Deploy completo (provisioning + deployment)
azd up

Il comando azd up esegue automaticamente:

1. Provisioning di Resource Group, Container Registry, Log Analytics, Container Apps Environment
2. Build dei progetti come container images
3. Push delle immagini su Azure Container Registry
4. Deployment su Azure Container Apps

Accesso all’Applicazione Deployata

Dopo il deployment, azd fornisce:

• URL pubblici dei servizi
• Link alla Dashboard Aspire deployata
• Link al portale Azure per monitoring

12. Deployment su Kubernetes

Per deployment su Kubernetes si utilizza lo strumento open-source Aspir8.

Installazione Aspir8

dotnet tool install -g aspirate

Workflow Deployment

# Inizializza Aspir8
cd MyApp.AppHost
aspirate init -cr myregistry.azurecr.io -ct latest

# Genera manifest Kubernetes
aspirate generate --image-pull-policy Always

# Apply su cluster
kubectl config use-context my-cluster
aspirate apply -k my-cluster

Aspir8 genera automaticamente:

• Deployment YAML
• Service definitions
• ConfigMaps e Secrets
• Persistent Volume Claims per database

13. Pro e Contro di Microsoft Aspire

Vantaggi

Produttività Accelerata: I nuovi sviluppatori possono avere l’intero sistema in esecuzione localmente in meno di un’ora, rispetto ai giorni necessari per configurare manualmente microservizi, database e code.

Osservabilità Integrata: Telemetria, logging e tracing distribuiti configurati automaticamente senza codice aggiuntivo.

Standardizzazione: ServiceDefaults garantisce configurazioni consistenti su tutti i servizi.

Resilienza Built-in: Retry automatici, circuit breaker e health check preconfigurati.

Developer Experience: Dashboard unificata per monitoraggio in tempo reale durante lo sviluppo.

Deployment Semplificato: Integrazione nativa con Azure Developer CLI e supporto Kubernetes tramite Aspir8.

Svantaggi

Vendor Lock-in Parziale: Aspire è progettato per lavorare strettamente con Azure, quindi le aziende che utilizzano altre piattaforme cloud potrebbero incontrare limitazioni o difficoltà di integrazione.

Curva di Apprendimento: Richiede comprensione di concetti distribuiti, orchestrazione e containerizzazione.

Monorepo Requirement: Tutti i progetti devono essere in un’unica solution, ma in pratica i team spesso lavorano su repository multipli.

Maturità del Tooling: Essendo un progetto relativamente nuovo, alcune feature sono ancora in evoluzione.

Overhead per Progetti Semplici: Per applicazioni monolitiche o con pochi servizi, l’overhead potrebbe non giustificare i benefici.

14. Conclusioni: L’Importanza della Formazione Continua

L’ecosistema .NET evolve rapidamente e tecnologie come Microsoft Aspire rappresentano un cambio di paradigma significativo nello sviluppo cloud-native. Aspire semplifica notevolmente la complessità intrinseca delle architetture distribuite, ma richiede competenze aggiornate per essere sfruttato efficacemente.

La formazione continua del team IT è l’unico modo per mantenere le persone aggiornate e produttive sui progetti, garantendo l’utilizzo di stack di sviluppo moderni e competitivi. Investire nella crescita professionale del team significa ridurre il time-to-market, migliorare la qualità del codice e aumentare la capacità di innovazione dell’organizzazione.

Opportunità Formative con Innovaformazione

Per approfondire Microsoft Aspire e le tecnologie cloud-native .NET, Innovaformazione offre percorsi formativi specializzati:

• Corso Microsoft Aspire attivabile su richiesta per le aziende
• Modalità: Online in classe virtuale
• Calendario: Flessibile e concordabile in base alle esigenze aziendali
• Accesso ai fondi Fondimpresa: Possibilità di ottenere la formazione gratuitamente attraverso progetti formativi finanziati, con supporto completo per l’intero iter

Scopri il catalogo completo dei corsi sul sito QUI.

INFO: info@innovaformazione.net – TEL. 3471012275 (Dario Carrassi)

Investire nella formazione significa investire nel futuro tecnologico della vostra organizzazione.

Per altri articoli tecnici sul mondo IT consigliamo di navigare sul nostro blog QUI.

(fonte) (fonte) (fonte)