Guida: Aggiungere Aspire a un'app .NET esistente

Se hai microservizi esistenti e .NET app Web, puoi aggiungere Aspire a questo e ottenere tutte le funzionalità e i vantaggi inclusi. In questo articolo aggiungi Aspire l'orchestrazione a un progetto semplice e preesistente .NET 9. Imparerete come:

Comprendere la struttura dell'app di microservizi esistente.
Registrare progetti esistenti nell'Aspire orchestrazione.
Comprendere le modifiche apportate dall'iscrizione nei progetti.
Avviare il Aspire progetto.

Prerequisites

Per usare Aspire, è necessario quanto segue installato in locale:

.NET 8.0 o .NET 9.0.
- Aspire A partire dalla versione 9.4, .NET è supportata la versione 10 Preview 5 o successiva.
Un runtime container conforme a OCI, come ad esempio:
- Docker Desktop o Podman. Per ulteriori informazioni, vedere Runtime del container.
Un ambiente di sviluppo integrato (IDE) o un editor di codice, ad esempio:
- Visual Studio 2022 versione 17.9 o successiva (facoltativo)
- Visual Studio Code (facoltativo)
  - C# Dev Kit: Estensione (facoltativo)
- JetBrains Rider con Aspire plugin (facoltativo)

Per altre informazioni, vedere Aspire Configurazione e strumenti e Aspire SDK.

Get started

Iniziamo ottenendo il codice per la soluzione:

Aprire un prompt dei comandi e modificare le directory in cui archiviare il codice.

Per clonare la soluzione di esempio .NET 9, usare il comando seguente git clone:

git clone https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops.git eShopLite

Esplorare l'app di esempio

Questo articolo usa una soluzione .NET 9 con tre progetti:

Entità dati: questo progetto è una libreria di classi di esempio. Definisce la classe Product usata nell'app Web e nell'API Web.
Products: questa API Web di esempio restituisce un elenco di prodotti nel catalogo e le relative proprietà.
Store: questo esempio di Blazor Web App visualizza il catalogo dei prodotti per i visitatori del sito web.

Architettura di app di esempio

Per comprendere meglio la struttura dell'app di esempio, prendere in considerazione il diagramma seguente, che illustra la semplice architettura a tre livelli:

Questa progettazione a più livelli garantisce una netta separazione delle problematiche, semplificando la manutenzione e la scalabilità dell'app.

Eseguire l'app di esempio

Aprire e avviare il debug del progetto per esaminarne il comportamento predefinito:

Avvia Visual Studio e quindi seleziona File>Apri>Progetto/Soluzione.
Passare alla cartella di primo livello della soluzione clonata, selezionare eShopLite.slne quindi selezionare Apri.
Nell'Esplora soluzioni , fare clic con il pulsante destro del mouse sulla soluzione eShopLite e quindi selezionare Configura progetti di avvio.
Selezionare Multipli progetti di avvio.
Nella colonna Azione, selezionare Avvia per entrambi i progetti Products e Store.
Seleziona OK.
Per avviare il debug della soluzione, premere F5 oppure selezionare Avvia.
Due pagine aperte nel browser:
- Una pagina visualizza i prodotti in formato JSON da una chiamata all'API Web dei Prodotti.
- Una pagina visualizza la home page del sito Web. Nel menu a sinistra selezionare Products per visualizzare il catalogo ottenuto dall'API Web.
Per arrestare il debug, chiudere il browser.

Avviare Visual Studio Code e aprire la cartella clonata. Dal terminale in cui è stato clonato il repository, eseguire il comando seguente:
```
code .
```
Selezionare la voce di menu Esegui e Debug, oppure premere Ctrl+Shift+D.
Seleziona il collegamento per creare un file launch.json.

Copiare e incollare il seguente JSON in questo file e Salvare:

Unix
Windows

{
    "version": "0.2.0",
    "compounds": [
        {
            "name": "Run all",
            "configurations": [
                "Run products",
                "Run store",
            ]
        }
    ],
    "configurations": [
        {
            "name": "Run products",
            "type": "dotnet",
            "request": "launch",
            "projectPath": "${workspaceFolder}/Products/Products.csproj"
        },
        {
            "name": "Run store",
            "type": "dotnet",
            "request": "launch",
            "projectPath": "${workspaceFolder}/Store/Store.csproj"
        }
    ]
}

{
    "version": "0.2.0",
    "compounds": [
        {
            "name": "Run all",
            "configurations": [
                "Run products",
                "Run store",
            ]
        }
    ],
    "configurations": [
        {
            "name": "Run products",
            "type": "dotnet",
            "request": "launch",
            "projectPath": "${workspaceFolder}\\Products\\Products.csproj"
        },
        {
            "name": "Run store",
            "type": "dotnet",
            "request": "launch",
            "projectPath": "${workspaceFolder}\\Store\\Store.csproj"
        }
    ]
}

Per avviare il debug della soluzione, premere F5 oppure selezionare Avvia.
Due pagine aperte nel browser:
- Una pagina visualizza i prodotti in formato JSON da una chiamata all'API Web dei Prodotti.
- Una pagina visualizza la home page del sito Web. Nel menu a sinistra selezionare Products per visualizzare il catalogo ottenuto dall'API Web.
Per arrestare il debug, chiudere il browser e quindi selezionare il pulsante Arresta due volte (una per ogni istanza di debug in esecuzione).

Aprire una finestra del terminale e modificare le directory nel repository appena clonato.
Per avviare l'app Products , eseguire il comando seguente:
```
dotnet run --project ./Products/Products.csproj
```
Si apre una pagina del browser che mostra il JSON per i prodotti.
In una finestra del terminale separata, cambiare nuovamente directory al repository clonato.
Avvia l'app dello Store eseguendo il comando seguente:
```
dotnet run --project ./Store/Store.csproj
```
Il browser apre una pagina che visualizza la home page del sito Web. Nel menu a sinistra selezionare Products per visualizzare il catalogo ottenuto dall'API Web.
Per arrestare il debug, chiudere il browser e premere CTRL+C in entrambi i terminali.

Indipendentemente dallo strumento usato, l'avvio manuale o la configurazione di più progetti tra di essi è noioso. Inoltre, il progetto store richiede una configurazione endpoint esplicita per l'API Products , che è sia complessa che soggetta a errori. Questo è il modo in cui Aspire semplifica e ottimizza il processo!

Verificare che i modelli Aspire siano installati

Se hai già lavorato con Aspire sul tuo computer corrente, è probabile che i modelli di progetto necessari .NET siano già installati. È possibile controllare usando il comando seguente:

dotnet new list aspire

Se i Aspire modelli sono installati, l'output sarà simile al seguente:

These templates matched your input: 'Aspire'

Template Name       Short Name              Language  Tags
------------------  ----------------------  --------  -------------------------------------------------------------------------------
Aspire App...  aspire-apphost          [C#]      Common/Aspire/Cloud
Aspire Emp...  aspire                  [C#]      Common/Aspire/Cloud/Web/Web API/API/Service
Aspire Ser...  aspire-servicedefaults  [C#]      Common/Aspire/Cloud/Web/Web API/API/Service
Aspire Sta...  aspire-starter          [C#]      Common/Aspire/Blazor/Web/Web API/API/Service/Cloud/Test/MSTest/NUnit/xUnit
Aspire Tes...  aspire-mstest           [C#]      Common/Aspire/Cloud/Web/Web API/API/Service/Test/MSTest
Aspire Tes...  aspire-nunit            [C#]      Common/Aspire/Cloud/Web/Web API/API/Service/Test/NUnit
Aspire Tes...  aspire-xunit            [C#]      Common/Aspire/Cloud/Web/Web API/API/Service/Test/xUnit

In questa esercitazione si aggiungeranno un progetto AppHost e un progetto Service Defaults.

Se il comando precedente non ha trovato modelli, è necessario installarli. Eseguire questo comando:

dotnet new install Aspire.ProjectTemplates

Per altre informazioni sui Aspire modelli, vedere Aspire Modelli

Aggiungere Aspire all'app Web dello Store

A questo punto, iscriviamo il progetto Store, che implementa l'interfaccia utente Web, nell'orchestrazione Aspire:

In Visual Studio, in Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Store , scegliere Aggiungi e quindi selezionare Aspire Supporto orchestratore.
Nella finestra di dialogo Aggiungi Aspire supporto orchestratore selezionare OK.

È ora necessario avere due nuovi progetti, entrambi aggiunti alla soluzione:

eShopLite.AppHost: un progetto orchestratore progettato per connettere e configurare i diversi progetti e servizi della tua app. L'orchestratore è impostato come progetto di avvioe dipende dal progetto eShopLite.Store.
eShopLite.ServiceDefaults: progetto Aspire condiviso per gestire le configurazioni riutilizzate nei progetti della soluzione correlate alla resilienza, all'individuazione dei servizi e ai dati di telemetria.

Nel progetto eShopLite.AppHost, aprire il file AppHost.cs. Si noti questa riga di codice, che registra il progetto Store nell'orchestrazione Aspire :

builder.AddProject<Projects.Store>("store");

Per altre informazioni, vedere AddProject.

Per aggiungere il progetto Products a Aspire:

In Visual Studio, in Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Prodotti , scegliere Aggiungi e quindi selezionare Aspire Supporto orchestratore.
Finestra di dialogo che indica che il progetto Orchestrator esiste già, seleziona OK.

Nel progetto eShopLite.AppHost, aprire il file AppHost.cs. Si noti questa riga di codice, che registra il progetto Products nell'orchestrazione Aspire :

builder.AddProject<Projects.Products>("products");

Si noti anche che il progetto eShopLite.AppHost dipende ora sia dal progetto Store che dal progetto Products.

Creare un progetto AppHost

Per orchestrare i progetti esistenti, è necessario creare un nuovo progetto AppHost . Per creare un nuovo progetto AppHost dai modelli disponibiliAspire, usare il seguente comando CLI.NET:

dotnet new aspire-apphost -o eShopLite.AppHost

Aggiungere il progetto AppHost alla soluzione esistente:

Unix
Windows

dotnet sln ./eShopLite.sln add ./eShopLite.AppHost/eShopLite.AppHost.csproj

dotnet sln .\eShopLite.sln add .\eShopLite.AppHost\eShopLite.AppHost.csproj

Aggiungere il progetto Store come riferimento di progetto al progetto AppHost usando il seguente comando CLI .NET:

Unix
Windows

dotnet add ./eShopLite.AppHost/eShopLite.AppHost.csproj reference ./Store/Store.csproj

dotnet add .\eShopLite.AppHost\eShopLite.AppHost.csproj reference .\Store\Store.csproj

Per altre informazioni sui modelli disponibili, vedere Aspire Modelli.

Creare un progetto di impostazioni predefinite del servizio

Dopo aver creato il progetto AppHost, è necessario creare un nuovo progetto predefinito del servizio . Per creare un nuovo progetto di impostazioni predefinite del servizio dai modelli disponibili, usare il seguente comando CLI:

dotnet new aspire-servicedefaults -o eShopLite.ServiceDefaults

Per aggiungere il progetto alla soluzione, usare il seguente comando .NET dell'interfaccia a riga di comando:

Unix
Windows

dotnet sln ./eShopLite.sln add ./eShopLite.ServiceDefaults/eShopLite.ServiceDefaults.csproj

dotnet sln .\eShopLite.sln add .\eShopLite.ServiceDefaults\eShopLite.ServiceDefaults.csproj

Aggiornare il progetto AppHost per aggiungere un riferimento al progetto Products :

Unix
Windows

dotnet add ./eShopLite.AppHost/eShopLite.AppHost.csproj reference ./Products/Products.csproj

dotnet add .\eShopLite.AppHost\eShopLite.AppHost.csproj reference .\Products\Products.csproj

Sia il progetto Store che Products devono fare riferimento al progetto dei valori predefiniti del servizio in modo che possano includere facilmente la scoperta dei servizi . Per aggiungere un riferimento al progetto predefinito del servizio nel progetto Store , usare il seguente comando CLI .NET:

Unix
Windows

dotnet add ./Store/Store.csproj reference ./eShopLite.ServiceDefaults/eShopLite.ServiceDefaults.csproj

dotnet add .\Store\Store.csproj reference .\eShopLite.ServiceDefaults\eShopLite.ServiceDefaults.csproj

Lo stesso comando, con percorsi leggermente diversi, dovrebbe essere utilizzato per aggiungere un riferimento al progetto delle impostazioni predefinite del servizio nel progetto Products.

Unix
Windows

dotnet add ./Products/Products.csproj reference ./eShopLite.ServiceDefaults/eShopLite.ServiceDefaults.csproj

dotnet add .\Products\Products.csproj reference .\eShopLite.ServiceDefaults\eShopLite.ServiceDefaults.csproj

Nei progetti Store e Products, aggiornare i loro file di Program.cs, aggiungendo la riga seguente immediatamente dopo la riga var builder = WebApplication.CreateBuilder(args);.

builder.AddServiceDefaults();

Aggiornare il progetto AppHost

Aprire il AppHost.cs file del progetto AppHost e sostituirlo con il codice C# seguente:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddProject<Projects.Store>("store");

builder.AddProject<Projects.Products>("products");

builder.Build().Run();

Il codice precedente:

Crea una nuova istanza di DistributedApplicationBuilder.
Aggiunge il progetto Store all'orchestratore.
Aggiunge il progetto Products all'orchestratore.
Compila e esegue l'orchestratore.

Individuazione dei servizi

A questo punto, entrambi i progetti fanno parte dell'orchestrazioneAspire, ma il progetto Store deve basarsi sull'indirizzo backend di Products attraverso il servizio di individuazione di Aspire. Per abilitare l'individuazione dei servizi, aprire il file di AppHost.cs in progetto eShopLite.AppHost e aggiornare il codice in modo che l'builder aggiunga un riferimento al progetto Products:

var builder = DistributedApplication.CreateBuilder(args);

var products = builder.AddProject<Projects.Products>("products");

builder.AddProject<Projects.Store>("store")
       .WithExternalHttpEndpoints()
       .WithReference(products)
       .WaitFor(products);

builder.Build().Run();

Il codice precedente indica che il progetto Store dipende dal progetto Products. Per altre informazioni, vedere Aspire AppHost: Risorse di riferimento. Questo riferimento viene usato per individuare l'indirizzo del progetto di Products in fase di esecuzione. Inoltre, il progetto Store è configurato per utilizzare endpoint HTTP esterni. Se in un secondo momento si sceglie di distribuire questa app, è necessario effettuare la chiamata a WithExternalHttpEndpoints per assicurarsi che sia pubblico verso l'esterno. Infine, l'API garantisce che l'app WaitFordello Store attenda che l'app Products sia pronta per la gestione delle richieste.

Aggiorna quindi il appsettings.json nel progetto store con il seguente JSON:

{
  "DetailedErrors": true,
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ProductEndpoint": "http://products",
  "ProductEndpointHttps": "https://products"
}

Gli indirizzi per entrambi gli endpoint ora usano il nome "products" aggiunto all'agente di orchestrazione in AppHost. Questi nomi vengono usati per individuare l'indirizzo del progetto Products.

Esplora l'app a cui sei iscritto

Iniziamo la soluzione ed esaminiamo il nuovo comportamento che Aspire fornisce.

Note

Si noti che il nuovo progetto di avvio è il progetto eShopLite.AppHost.

In Visual Studio, per avviare il debug e compilare i progetti, premere F5Visual Studio.
Se viene visualizzata la finestra di dialogo Start Docker Desktop, selezionare Sì. Visual Studio avvia il motore di Docker e crea i contenitori necessari. Al termine della distribuzione, viene visualizzato il Aspire dashboard.
Nella dashboard, selezionare l'endpoint per il progetto dei prodotti . Viene visualizzata una nuova scheda del browser e viene visualizzato il catalogo prodotti in formato JSON.
Nel pannello di controllo, selezionare l'endpoint per il progetto store . Quando si apre una nuova scheda del browser, viene visualizzata la home page dell'app web.
Nel menù a sinistra selezionare Prodotti. Viene visualizzato il catalogo prodotti.
Per arrestare il debug, chiudere il browser.

Eliminare il file launch.json creato in precedenza, non serve più a scopo. Avviare invece il progetto AppHost , che orchestra gli altri progetti:

Avviare il progetto AppHost facendo clic con il pulsante destro del mouse sul progetto eShopLite.AppHost in Esplora soluzioni e scegliendo Avvia debug>Nuova istanza:

Note

Se Docker Desktop (o Podman) non è in esecuzione, si verifica un errore. Avviare il runtime del contenitore e riprovare.

Avviare il progetto AppHost eseguendo il comando seguente:
```
dotnet run --project ./eShopLite.AppHost/eShopLite.AppHost.csproj
```
Note

Se Docker Desktop (o Podman) non è in esecuzione, si verifica un errore. Avviare il runtime del contenitore e riprovare.

Nella dashboard, selezionare l'endpoint per il progetto dei prodotti . Viene visualizzata una nuova scheda del browser e viene visualizzato il catalogo prodotti in formato JSON.
Nel pannello di controllo, selezionare l'endpoint per il progetto store . Quando si apre una nuova scheda del browser, viene visualizzata la home page dell'app web.
Nel menù a sinistra selezionare Prodotti. Viene visualizzato il catalogo prodotti.
Per arrestare il debug, chiudere il browser.

Complimenti, hai aggiunto Aspire l'orchestrazione alla tua app Web preesistente. È ora possibile aggiungere integrazioni Aspire e usare gli strumenti Aspire per semplificare lo sviluppo di app Web native del cloud.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-10-02