Le applicazioni moderne raramente vivono isolate: quasi sempre devono connettersi a risorse esterne come database, code di messaggi, cache distribuite o API di terze parti. La gestione di queste dipendenze è spesso uno dei punti più complessi nello sviluppo cloud native, soprattutto quando si passa da ambiente locale a cloud.

Con .NET Aspire, l’integrazione con risorse esterne diventa parte naturale del flusso di sviluppo. Che si tratti di un container in locale o di un servizio gestito in cloud, Aspire fornisce un modello uniforme per dichiarare, collegare e utilizzare queste risorse.

Tipologie di risorse

In Aspire possiamo distinguere principalmente tre categorie di risorse esterne:

• Database (SQL Server, PostgreSQL, MongoDB, ecc.)
• Messaggistica e cache (RabbitMQ, Kafka, Redis, ecc.)
• Servizi esterni (API REST di terze parti, servizi cloud come Azure Storage, Service Bus, ecc.)

Un esempio con SQL Server

Vediamo come collegare un progetto API a un database SQL Server.

AppHost/Program.cs:

var builder = DistributedApplication.CreateBuilder(args);

// Definiamo un'istanza di SQL Server con un database
var sql = builder.AddSqlServer("sql")
    .WithDataVolume()
    .AddDatabase("appdb");

// Colleghiamo l'API al DB
builder.AddProject<Projects.MyApi>("api")
    .WithReference(sql);

builder.Build().Run();

In questo modo, l’API riceverà automaticamente la connection string per appdb.

MyApi/Program.cs:

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("appdb");

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(connectionString));

var app = builder.Build();

app.MapGet("/products", (AppDbContext db) => db.Products.ToList());

app.Run();

Nessuna configurazione manuale di stringhe di connessione: Aspire gestisce tutto.

Un esempio con RabbitMQ

Supponiamo ora di voler integrare una coda di messaggi con RabbitMQ.

AppHost/Program.cs:

var builder = DistributedApplication.CreateBuilder(args);

var rabbit = builder.AddContainer("rabbitmq", "rabbitmq:3-management")
    .WithEndpoint("amqp", 5672)
    .WithEndpoint("management", 15672);

builder.AddProject<Projects.MyWorker>("worker")
    .WithReference(rabbit);

builder.Build().Run();

MyWorker/Program.cs:

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddSingleton<IConnectionFactory>(_ =>
    new ConnectionFactory
    {
        Uri = new Uri(builder.Configuration.GetConnectionString("rabbitmq"))
    });

builder.Services.AddHostedService<Worker>();

builder.Build().Run();

Il worker riceverà in automatico la connection string per RabbitMQ, senza doverla configurare a mano.

Integrazione con API esterne

Non sempre le risorse sono container o database: a volte bisogna collegarsi a API di terze parti. Aspire permette di dichiarare anche queste come risorse.

AppHost/Program.cs:

var builder = DistributedApplication.CreateBuilder(args);

// Definiamo un'API esterna
var weatherApi = builder.AddHttpApi("weather", "https://api.open-meteo.com");

// Colleghiamo il frontend all'API
builder.AddProject<Projects.MyFrontend>("frontend")
    .WithReference(weatherApi);

builder.Build().Run();

MyFrontend/Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpClient("weather", client =>
{
    client.BaseAddress = new Uri(
        builder.Configuration.GetConnectionString("weather"));
});

var app = builder.Build();

app.MapGet("/forecast", async (IHttpClientFactory httpClientFactory) =>
{
    var client = httpClientFactory.CreateClient("weather");
    return await client.GetStringAsync("/v1/forecast?latitude=52.52&longitude=13.41&daily=temperature_2m_max");
});

app.Run();

Anche in questo caso Aspire fornisce al progetto l’endpoint corretto.

Cosa fa Aspire dietro le quinte

In tutti gli esempi visti, Aspire gestisce automaticamente aspetti complessi che normalmente richiederebbero configurazioni manuali:

• Provisioning delle risorse locali: avvia container (SQL Server, RabbitMQ, Redis) e li collega ai progetti.
• Gestione degli endpoint: genera e distribuisce connection string uniformi ai progetti che fanno riferimento alla risorsa.
• Networking interno: assicura che i progetti e le risorse siano sulla stessa rete, evitando conflitti di porte.
• Supporto multi-ambiente: la stessa definizione può puntare a risorse locali in sviluppo e a servizi gestiti in cloud in produzione.
• Dashboard: ti mostra in tempo reale le connessioni attive, i log delle risorse e lo stato dei container.

In altre parole, Aspire trasforma il collegamento con risorse esterne in un processo dichiarativo e uniforme, indipendente dal contesto di esecuzione.

Conclusioni

L’integrazione con risorse esterne è spesso uno degli aspetti più complessi nello sviluppo di applicazioni distribuite. Con .NET Aspire, invece, diventa semplice e coerente: definisci le risorse nell’AppHost, colleghi i progetti e Aspire si occupa di tutto il resto.

Questo approccio riduce il rischio di errori di configurazione, accelera lo sviluppo e garantisce consistenza tra ambienti diversi.

Nel prossimo articolo parleremo di sicurezza e gestione dell’identity in .NET Aspire, un tema cruciale per proteggere applicazioni distribuite e cloud native.