Condividi tramite

Distribuzione e ridimensionamento di un'app ASP.NET Core nelle app Azure Container

  • Articolo

Le app distribuite in Azure che hanno un'elevata domanda intermittente traggono vantaggio dalla scalabilità per soddisfare la domanda. Le app scalabili possono aumentare le prestazioni per garantire la capacità durante i picchi del carico di lavoro e quindi ridurle automaticamente quando il picco scende, che può ridurre i costi. La scalabilità orizzontale (aumento del numero di istanze) aggiunge nuove istanze di una risorsa, ad esempio macchine virtuali o repliche di database. Questo articolo illustra come distribuire un'app ASP.NET Core scalabile orizzontalmente nelle app contenitore di Azure completando le attività seguenti:

  1. Configurare il progetto di esempio
  2. Distribuire l'app in App Azure Container
  3. Ridimensionare e risolvere i problemi dell'app
  4. Creare i servizi di Azure
  5. Connessione i servizi di Azure
  6. Configurare e ridistribuire l'app

Questo articolo usa Razor Pages, ma la maggior parte di essa si applica ad altre app ASP.NET Core.

In alcuni casi, le app di base ASP.NET Core possono essere ridimensionate senza particolari considerazioni. Tuttavia, le app che usano determinate funzionalità del framework o modelli architetturali richiedono configurazioni aggiuntive, incluse le seguenti:

  • Invii di moduli protetti: Razor pagine, app MVC e API Web spesso si basano sugli invii di moduli. Per impostazione predefinita, queste app usano token di falsità tra siti e servizi di protezione dei dati interni per proteggere le richieste. Quando vengono distribuite nel cloud, queste app devono essere configurate per gestire i problemi del servizio di protezione dei dati in una posizione centralizzata sicura.

  • SignalRcircuiti: Blazor Server le app richiedono l'uso di un servizio di Azure SignalR centralizzato per ridimensionare in modo sicuro. Questi servizi usano anche i servizi di protezione dei dati indicati in precedenza.

  • Servizi centralizzati di memorizzazione nella cache o gestione dello stato: le app scalabili possono usare cache di Azure per Redis per fornire la memorizzazione nella cache distribuita. L'archiviazione di Azure può essere necessaria per archiviare lo stato per framework come Microsoft Orleans, che consente di scrivere app che gestiscono lo stato in molte istanze diverse dell'app.

I passaggi descritti in questo articolo illustrano come risolvere correttamente i problemi precedenti distribuendo un'app scalabile in App Contenitore di Azure. La maggior parte dei concetti di questa esercitazione si applica anche quando si ridimensionano app Azure istanze del servizio.

Configurare il progetto di esempio

Usare l'app di esempio GitHub Explorer per seguire questa esercitazione. Clonare l'app da GitHub usando il comando seguente:

git clone "https://github.com/dotnet/AspNetCore.Docs.Samples.git"

Passare alla /tutorials/scalable-razor-apps/start cartella e aprire .ScalableRazor.csproj

L'app di esempio usa un modulo di ricerca per esplorare i repository GitHub in base al nome. Il modulo si basa sui servizi predefiniti di protezione dei dati di ASP.NET Core per gestire le problematiche antigerosia. Per impostazione predefinita, quando l'app viene ridimensionata orizzontalmente in App contenitore, il servizio di protezione dei dati genera un'eccezione.

Testare l'app

  1. Avviare l'app in Visual Studio. Il progetto include un file Docker, il che significa che la freccia accanto al pulsante di esecuzione può essere selezionata per avviare l'app usando un'installazione di Docker Desktop o il server Web locale standard ASP.NET Core.

Usare il modulo di ricerca per cercare i repository GitHub in base al nome.

A screenshot showing the GitHub Explorer app.

Distribuire l'app in App Azure Container

Visual Studio viene usato per distribuire l'app in App Azure Container. Le app contenitore offrono un servizio gestito progettato per semplificare l'hosting di app e microservizi in contenitori.

Nota

Molte delle risorse create per l'app richiedono una posizione. Per questa app, la posizione non è importante. Un'app reale deve selezionare una posizione più vicina ai client. È possibile selezionare una posizione nelle vicinanze.

  1. In Esplora soluzioni di Visual Studio fare clic con il pulsante destro del mouse sul nodo del progetto di primo livello e scegliere Pubblica.

  2. Nella finestra di dialogo di pubblicazione selezionare Azure come destinazione di distribuzione e quindi selezionare Avanti.

  3. Per la destinazione specifica, selezionare App Contenitore di Azure (Linux) e quindi selezionare Avanti.

  4. Creare una nuova app contenitore in cui eseguire la distribuzione. Selezionare l'icona verde + per aprire una nuova finestra di dialogo e immettere i valori seguenti:

    A screenshot showing Visual Studio deployment.

    • Nome app contenitore: lasciare il valore predefinito o immettere un nome.
    • Nome sottoscrizione: selezionare la sottoscrizione in cui eseguire la distribuzione.
    • Gruppo di risorse: selezionare Nuovo e creare un nuovo gruppo di risorse denominato msdocs-scalable-razor.
    • Ambiente app contenitore: selezionare Nuovo per aprire la finestra di dialogo dell'ambiente delle app contenitore e immettere i valori seguenti:
      • Nome ambiente: mantenere il valore predefinito.
      • Località: selezionare una località nelle vicinanze.
      • Area di lavoro Log Analytics di Azure: selezionare Nuovo per aprire la finestra di dialogo dell'area di lavoro Log Analytics.
        • Nome: lasciare il valore predefinito.
        • Località: selezionare una posizione nelle vicinanze e quindi selezionare OK per chiudere la finestra di dialogo.
      • Selezionare OK per chiudere la finestra di dialogo dell'ambiente delle app contenitore.
    • Selezionare Crea per chiudere la finestra di dialogo originale per le app contenitore. Visual Studio crea la risorsa dell'app contenitore in Azure.

  5. Dopo aver creato la risorsa, assicurarsi che sia selezionata nell'elenco delle app contenitore e quindi selezionare Avanti.

  6. Dovrai creare un Registro Azure Container per archiviare l'artefatto dell'immagine pubblicata per la tua app. Selezionare l'icona verde + nella schermata registro contenitori.

    A screenshot showing how to create a new container registry.

  7. Lasciare i valori predefiniti e quindi selezionare Crea.

    A screenshot showing the values for a new container registry.

  8. Dopo aver creato il registro contenitori, assicurarsi che sia selezionato e quindi selezionare Fine per chiudere il flusso di lavoro della finestra di dialogo e visualizzare un riepilogo del profilo di pubblicazione.

    Se Visual Studio richiede di abilitare l'utente Amministrazione ad accedere al contenitore Docker pubblicato, selezionare Sì.

  9. Selezionare Pubblica in alto a destra nel riepilogo del profilo di pubblicazione per distribuire l'app in Azure.

Al termine della distribuzione, Visual Studio avvia il browser per visualizzare l'app ospitata. Microsoft Cercare nel campo modulo e viene visualizzato un elenco di repository.

Ridimensionare e risolvere i problemi dell'app

L'app funziona attualmente senza problemi, ma si vuole ridimensionare l'app in più istanze in previsione di volumi di traffico elevati.

  1. Nella portale di Azure cercare l'app razorscaling-app-**** contenitore nella barra di ricerca di primo livello e selezionarla dai risultati.
  2. Nella pagina di panoramica selezionare Ridimensiona nel riquadro di spostamento a sinistra e quindi selezionare + Modifica e distribuzione.
  3. Nella pagina revisioni passare alla scheda Scala .
  4. Impostare sia le istanze min che max su 4 e quindi selezionare Crea. Questa modifica di configurazione garantisce che l'app venga ridimensionata orizzontalmente tra quattro istanze.

Tornare all'app. Quando la pagina viene caricata, all'inizio viene visualizzato tutto funziona correttamente. Tuttavia, quando viene immesso e inviato un termine di ricerca, può verificarsi un errore. Se non viene visualizzato un errore, inviare il modulo più volte.

Risoluzione dell'errore

Non è immediatamente evidente il motivo per cui le richieste di ricerca hanno esito negativo. Gli strumenti del browser indicano che è stata inviata una risposta di richiesta non valida 400. Tuttavia, è possibile usare le funzionalità di registrazione delle app contenitore per diagnosticare gli errori che si verificano nell'ambiente.

  1. Nella pagina di panoramica dell'app contenitore selezionare Log nel riquadro di spostamento a sinistra.

  2. Nella pagina Log chiudere il popup che si apre e passare alla scheda Tabelle.

  3. Espandere l'elemento Log personalizzati per visualizzare il nodo ContainerAppConsoleLogs_CL . Questa tabella contiene vari log per l'app contenitore su cui è possibile eseguire query per risolvere i problemi.

    A screenshot showing the container app logs.

  4. Nell'editor di query comporre una query di base per cercare nella tabella ContainerAppConsoleLogs_CL Logs le eccezioni recenti, ad esempio lo script seguente:

    ContainerAppConsoleLogs_CL
| where Log_s contains "exception"
| sort by TimeGenerated desc
| limit 500
| project ContainerAppName_s, Log_s

    La query precedente cerca nella tabella ContainerAppConsoleLogs_CL tutte le righe che contengono l'eccezione di parola. I risultati vengono ordinati in base al tempo generato, limitati a 500 risultati e includono solo le colonne ContainerAppName_s e Log_s per semplificare la lettura dei risultati.

  5. Selezionare Esegui. Verrà visualizzato un elenco di risultati. Leggere i log e notare che la maggior parte di esse sono correlate ai token antiforgery e alla crittografia.

    A screenshot showing the logs query.

    Importante

    Gli errori nell'app sono causati dai servizi di protezione dei dati .NET. Quando sono in esecuzione più istanze dell'app, non esiste alcuna garanzia che la richiesta HTTP POST per inviare il modulo venga instradata allo stesso contenitore che inizialmente ha caricato la pagina dalla richiesta HTTP GET. Se le richieste vengono gestite da istanze diverse, i token antiforgery non vengono gestiti correttamente e si verifica un'eccezione.

    Nei passaggi successivi questo problema viene risolto centralizzando le chiavi di protezione dei dati in un servizio di archiviazione di Azure e proteggendole con Key Vault.

Creare i servizi di Azure

Per risolvere gli errori precedenti, vengono creati e connessi all'app i servizi seguenti:

  • Archiviazione di Azure Account: gestisce l'archiviazione dei dati per i servizi di protezione dati. Fornisce una posizione centralizzata per archiviare i dati delle chiavi man mano che l'app viene ridimensionata. Archiviazione account possono essere usati anche per contenere documenti, dati della coda, condivisioni file e quasi qualsiasi tipo di dati BLOB.
  • Azure KeyVault: questo servizio archivia i segreti per un'app e viene usato per gestire i problemi di crittografia per Data Protection Services.

Creare il servizio account di archiviazione

  1. Nella barra di ricerca portale di Azure immettere Storage accounts e selezionare il risultato corrispondente.
  2. Nella pagina di presentazione degli account di archiviazione selezionare + Crea.
  3. Nella scheda Informazioni di base immettere i valori seguenti:
    • Sottoscrizione: selezionare la stessa sottoscrizione scelta per l'app contenitore.
    • Gruppo di risorse: selezionare il gruppo di risorse msdocs-scalable-razor creato in precedenza.
    • Archiviazione nome dell'account: assegnare un nome all'account scalablerazorstorageXXXX in cui le X sono numeri casuali di propria scelta. Questo nome deve essere univoco in tutto Azure.
    • Area: selezionare la stessa area selezionata in precedenza.
  4. Lasciare invariati i valori predefiniti e selezionare Rivedi. Dopo che Azure convalida gli input, selezionare Crea.

Azure effettua il provisioning del nuovo account di archiviazione. Al termine dell'attività, scegliere Vai alla risorsa per visualizzare il nuovo servizio.

Creare il contenitore di archiviazione

Creare un contenitore per archiviare le chiavi di protezione dei dati dell'app.

  1. Nella pagina di panoramica per il nuovo account di archiviazione selezionare Archiviazione browser nel riquadro di spostamento a sinistra.
  2. Selezionare Contenitori BLOB.
  3. Selezionare + Aggiungi contenitore per aprire il menu a comparsa Nuovo contenitore .
  4. Immettere un nome di scalablerazorkeys, lasciare invariate le impostazioni predefinite e quindi selezionare Crea.

I nuovi contenitori vengono visualizzati nell'elenco di pagine.

Creare il servizio dell'insieme di credenziali delle chiavi

Creare un insieme di credenziali delle chiavi per contenere le chiavi che proteggono i dati nel contenitore di archiviazione BLOB.

  1. Nella barra di ricerca portale di Azure immettere Key Vault e selezionare il risultato corrispondente.
  2. Nella pagina elenco dell'insieme di credenziali delle chiavi selezionare + Crea.
  3. Nella scheda Informazioni di base immettere i valori seguenti:
    • Sottoscrizione: selezionare la stessa sottoscrizione selezionata in precedenza.
    • Gruppo di risorse: selezionare il gruppo di risorse msdocs-scalable-razor creato in precedenza.
    • Nome dell'insieme di credenziali delle chiavi: immettere il nome scalablerazorvaultXXXX.
    • Area: selezionare un'area nelle vicinanze della località.
  4. Lasciare le altre impostazioni predefinite e quindi selezionare Rivedi e crea. Attendere che Azure convaliderà le impostazioni e quindi selezionare Crea.

Azure effettua il provisioning del nuovo insieme di credenziali delle chiavi. Al termine dell'attività, selezionare Vai alla risorsa per visualizzare il nuovo servizio.

Creare la chiave

Creare una chiave privata per proteggere i dati nell'account di archiviazione BLOB.

  1. Nella pagina di panoramica principale dell'insieme di credenziali delle chiavi selezionare Chiavi nel riquadro di spostamento a sinistra.
  2. Nella pagina Crea una chiave selezionare + Genera/Importa per aprire il menu a comparsa Crea una chiave .
  3. Immettere razorkey nel campo Nome . Lasciare invariati i valori predefiniti delle impostazioni rimanenti e quindi selezionare Crea. Nella pagina dell'elenco delle chiavi viene visualizzata una nuova chiave.

Connessione i servizi di Azure

L'app contenitore richiede una connessione sicura all'account di archiviazione e ai servizi dell'insieme di credenziali delle chiavi per risolvere gli errori di protezione dei dati e ridimensionare correttamente. I nuovi servizi vengono connessi insieme seguendo questa procedura:

Importante

Le assegnazioni di ruolo di sicurezza tramite service Connessione or e altri strumenti richiedono in genere un minuto o due per propagarsi e in alcuni casi rari possono richiedere fino a otto minuti.

Connessione l'account di archiviazione

  1. Nella portale di Azure passare alla pagina di panoramica dell'app contenitore.
  2. Nel riquadro di spostamento sinistro selezionare Connettore di servizi
  3. Nella pagina Service Connessione or scegliere + Crea per aprire il riquadro a comparsa Creazione Connessione ion e immettere i valori seguenti:
    • Contenitore: selezionare l'app contenitore creata in precedenza.
    • Tipo di servizio: scegliere Archiviazione - BLOB.
    • Sottoscrizione: selezionare la sottoscrizione usata in precedenza.
    • nome Connessione ion: lasciare il valore predefinito.
    • Archiviazione account: selezionare l'account di archiviazione creato in precedenza.
    • Tipo di client: selezionare .NET.
  4. Selezionare Avanti: Autenticazione per passare al passaggio successivo.
  5. Selezionare Identità gestita assegnata dal sistema e scegliere Avanti: Rete.
  6. Lasciare selezionata l'opzione di rete predefinita e quindi selezionare Rivedi e crea.
  7. Dopo che Azure convalida le impostazioni, selezionare Crea.

Il connettore del servizio abilita un'identità gestita assegnata dal sistema nell'app contenitore. Assegna inoltre un ruolo di collaboratore ai dati blob di Archiviazione all'identità in modo che possa eseguire operazioni sui dati nei contenitori di archiviazione.

Connessione l'insieme di credenziali delle chiavi

  1. Nella portale di Azure passare alla pagina di panoramica dell'app contenitore.
  2. Nel riquadro di spostamento a sinistra selezionare Connettore di servizi.
  3. Nella pagina Service Connessione or scegliere + Crea per aprire il riquadro a comparsa Creazione Connessione ion e immettere i valori seguenti:
    • Contenitore: selezionare l'app contenitore creata in precedenza.
    • Tipo di servizio: scegliere Key Vault.
    • Sottoscrizione: selezionare la sottoscrizione usata in precedenza.
    • nome Connessione ion: lasciare il valore predefinito.
    • Insieme di credenziali delle chiavi: selezionare l'insieme di credenziali delle chiavi creato in precedenza.
    • Tipo di client: selezionare .NET.
  4. Selezionare Avanti: Autenticazione per passare al passaggio successivo.
  5. Selezionare Identità gestita assegnata dal sistema e scegliere Avanti: Rete.
  6. Lasciare selezionata l'opzione di rete predefinita e quindi selezionare Rivedi e crea.
  7. Dopo che Azure convalida le impostazioni, selezionare Crea.

Il connettore del servizio assegna un ruolo all'identità in modo che possa eseguire operazioni sui dati sulle chiavi dell'insieme di credenziali delle chiavi.

Configurare e ridistribuire l'app

Sono state create le risorse di Azure necessarie. In questa sezione il codice dell'app è configurato per l'uso delle nuove risorse.

  1. Installare i pacchetti NuGet seguenti:

    • Azure.Identity: fornisce classi da usare con i servizi di gestione delle identità e degli accessi di Azure.
    • Microsoft.Extensions.Azure: fornisce metodi di estensione utili per eseguire configurazioni di Azure di base.
    • Azure.Extensions.AspNetCore.DataProtection.Blobs: consente di archiviare ASP.NET chiavi Core DataProtection in Archiviazione BLOB di Azure in modo che le chiavi possano essere condivise tra più istanze di un'app Web.
    • Azure.Extensions.AspNetCore.DataProtection.Keys: consente di proteggere le chiavi inattive usando la funzionalità crittografia/wrapping delle chiavi di Azure Key Vault.
    dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.Azure
dotnet add package Azure.Extensions.AspNetCore.DataProtection.Blobs
dotnet add package Azure.Extensions.AspNetCore.DataProtection.Keys

  2. Eseguire l'aggiornamento Program.cs con il codice evidenziato seguente:

    using Azure.Identity;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.Extensions.Azure;

var builder = WebApplication.CreateBuilder(args);
var BlobStorageUri = builder.Configuration["AzureURIs:BlobStorage"];
var KeyVaultURI = builder.Configuration["AzureURIs:KeyVault"];

builder.Services.AddRazorPages();
builder.Services.AddHttpClient();
builder.Services.AddServerSideBlazor();

builder.Services.AddAzureClientsCore();

builder.Services.AddDataProtection()
                .PersistKeysToAzureBlobStorage(new Uri(BlobStorageUri),
                                                new DefaultAzureCredential())
                .ProtectKeysWithAzureKeyVault(new Uri(KeyVaultURI),
                                                new DefaultAzureCredential());
var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Le modifiche precedenti consentono all'app di gestire la protezione dei dati usando un'architettura centralizzata e scalabile. DefaultAzureCredential individua le configurazioni di identità gestite abilitate in precedenza quando l'app viene ridistribuito.

Aggiornare i segnaposto nella AzureURIs sezione del appsettings.json file in modo da includere quanto segue:

  1. Sostituire il <storage-account-name> segnaposto con il nome dell'account scalablerazorstorageXXXX di archiviazione.

  2. Sostituire il <container-name> segnaposto con il nome del scalablerazorkeys contenitore di archiviazione.

  3. Sostituire il <key-vault-name> segnaposto con il nome dell'insieme di credenziali delle scalablerazorvaultXXXX chiavi.

  4. Sostituire il <key-name> segnaposto nell'URI dell'insieme di credenziali delle chiavi con il razorkey nome creato in precedenza.

    {
  "GitHubURL": "https://api.github.com",
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "AzureURIs": {
    "BlobStorage": "https://<storage-account-name>.blob.core.windows.net/<container-name>/keys.xml",
    "KeyVault": "https://<key-vault-name>.vault.azure.net/keys/<key-name>/"
  }
}

Ridistribuire l'app

L'app è ora configurata correttamente per l'uso dei servizi di Azure creati in precedenza. Ridistribuire l'app per applicare le modifiche al codice.

  1. Fare clic con il pulsante destro del mouse sul nodo del progetto in Esplora soluzioni e scegliere Pubblica.
  2. Nella visualizzazione di riepilogo del profilo di pubblicazione selezionare il pulsante Pubblica nell'angolo superiore destro.

Visual Studio ridistribuisce l'app nell'ambiente delle app contenitore creato in precedenza. Al termine dei processi, il browser viene avviato nella home page dell'app.

Testare di nuovo l'app cercando Microsoft nel campo di ricerca. La pagina dovrebbe ora ricaricarsi con i risultati corretti ogni volta che si invia.

Configurare i ruoli per lo sviluppo locale

Il codice e la configurazione esistenti dell'app possono funzionare anche durante l'esecuzione in locale durante lo sviluppo. La DefaultAzureCredential classe configurata in precedenza è in grado di raccogliere le credenziali dell'ambiente locale per l'autenticazione nei servizi di Azure. È necessario assegnare gli stessi ruoli al proprio account assegnato all'identità gestita dell'app per consentire il funzionamento dell'autenticazione. Questo deve essere lo stesso account usato per accedere a Visual Studio o all'interfaccia della riga di comando di Azure.

Accedere all'ambiente di sviluppo locale

È necessario accedere all'interfaccia della riga di comando di Azure, a Visual Studio o ad Azure PowerShell affinché le credenziali vengano prelevate da DefaultAzureCredential.

az login

Assegnare ruoli all'account sviluppatore

  1. Nella portale di Azure passare all'account scalablerazor**** di archiviazione creato in precedenza.
  2. Selezionare Controllo di accesso (IAM) nel riquadro di spostamento a sinistra.
  3. Scegliere + Aggiungi e quindi Aggiungi assegnazione di ruolo dal menu a discesa.
  4. Nella pagina Aggiungi assegnazione di ruolo cercare Storage blob data contributor, selezionare il risultato corrispondente e quindi selezionare Avanti.
  5. Assicurarsi che l'opzione Utente, gruppo o entità servizio sia selezionata e quindi selezionare + Seleziona membri.
  6. Nel riquadro a comparsa Seleziona membri cercare il proprio account user@domain e selezionarlo nei risultati.
  7. Scegliere Avanti e quindi Rivedi e assegna. Dopo che Azure convalida le impostazioni, selezionare di nuovo Rivedi e assegna .

Come indicato in precedenza, le autorizzazioni di assegnazione dei ruoli potrebbero richiedere un minuto o due per propagarsi o in rari casi fino a otto minuti.

Ripetere i passaggi precedenti per assegnare un ruolo all'account in modo che possa accedere al servizio e al segreto dell'insieme di credenziali delle chiavi.

  1. Nella portale di Azure passare all'insieme di credenziali delle razorscalingkeys chiavi creato in precedenza.
  2. Selezionare Controllo di accesso (IAM) nel riquadro di spostamento a sinistra.
  3. Scegliere + Aggiungi e quindi Aggiungi assegnazione di ruolo dal menu a discesa.
  4. Nella pagina Aggiungi assegnazione di ruolo cercare Key Vault Crypto Service Encryption User, selezionare il risultato corrispondente e quindi selezionare Avanti.
  5. Assicurarsi che l'opzione Utente, gruppo o entità servizio sia selezionata e quindi selezionare + Seleziona membri.
  6. Nel riquadro a comparsa Seleziona membri cercare il proprio account user@domain e selezionarlo nei risultati.
  7. Scegliere Avanti e quindi Rivedi e assegna. Dopo che Azure convalida le impostazioni, selezionare rivedi e assegna di nuovo.

Potrebbe essere necessario attendere di nuovo che l'assegnazione di ruolo venga propagata.

È quindi possibile tornare a Visual Studio ed eseguire l'app in locale. Il codice deve continuare a funzionare come previsto. DefaultAzureCredential usa le credenziali esistenti da Visual Studio o dall'interfaccia della riga di comando di Azure.

Modelli di app Web affidabili

Per indicazioni sulla creazione di un'app moderna, affidabile, affidabile, affidabile, testabile, conveniente e scalabile ASP.NET Core, indipendentemente dal fatto che si tratti di un'app esistente o di refactoring di un'app esistente, vedi Modello di app Web Reliable Web for.NETYouTube.