Esercitazione: Distribuire un'app ASP.NET Core e database SQL di Azure nel servizio app Azure
In questa esercitazione si apprenderà come distribuire un'app ASP.NET Core basata sui dati in app Azure Service e connettersi a un database SQL di Azure. Si distribuirà anche un cache di Azure per Redis per abilitare il codice di memorizzazione nella cache nell'applicazione. app Azure Service è un servizio di hosting Web altamente scalabile e scalabile che consente di distribuire facilmente app in Windows o Linux. Anche se questa esercitazione usa un'app ASP.NET Core 7.0, il processo è lo stesso per altre versioni di ASP.NET Core e ASP.NET Framework.
Questa esercitazione richiede:
- Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
- Un account GitHub. è anche possibile ottenere uno gratuitamente.
Applicazione di esempio
Per esplorare l'applicazione di esempio usata in questa esercitazione, scaricarla dal repository https://github.com/Azure-Samples/msdocs-app-service-sqldb-dotnetcore o clonarla usando il comando Git seguente:
git clone https://github.com/Azure-Samples/msdocs-app-service-sqldb-dotnetcore.git
cd msdocs-app-service-sqldb-dotnetcore
1. Creare servizio app, database e cache
In questo passaggio si creano le risorse di Azure. I passaggi usati in questa esercitazione creano un set di risorse sicure per impostazione predefinita che includono servizio app, database SQL di Azure e Cache di Azure. Per il processo di creazione, specificare:
- Nome dell'app Web. È il nome usato come parte del nome DNS per l'app Web sotto forma di
https://<app-name>.azurewebsites.net
. - Area in cui eseguire l'app fisicamente nel mondo.
- Stack di runtime per l'app. È qui che si seleziona la versione .NET da usare per l'app.
- Piano di hosting per l'app. Si tratta del piano tariffario che include il set di funzionalità e la capacità di ridimensionamento per l'app.
- Gruppo di risorse per l'app. Un gruppo di risorse consente di raggruppare (in un contenitore logico) tutte le risorse di Azure necessarie per l'applicazione.
Accedere al portale di Azure e seguire questa procedura per creare le risorse del servizio app Azure.
Passaggio 1: nel portale di Azure:
- Immettere "database dell'app Web" nella barra di ricerca nella parte superiore del portale di Azure.
- Selezionare l'elemento con etichetta App Web e database sotto l'intestazione Marketplace . È anche possibile passare direttamente alla creazione guidata .
Passaggio 2: nella pagina Crea app Web e database compilare il modulo come indicato di seguito.
- Gruppo di risorse → Selezionare Crea nuovo e usare un nome msdocs-core-sql-tutorial.
- Area → Qualsiasi area di Azure nelle vicinanze.
- Nome → msdocs-core-sql-XYZ dove XYZ è costituito da tre caratteri casuali. Il nome deve essere univoco in Azure
- Stack di runtime → .NET 7 (STS).
- Aggiungere cache di Azure per Redis? → Sì.
- Piano di hosting → Basic. Quando si è pronti, è possibile passare a un piano tariffario di produzione in un secondo momento.
- Selezionare SQLAzure come motore di database. database SQL di Azure è un motore di database PaaS (Platform as a Service) completamente gestito che è sempre in esecuzione nella versione stabile più recente di SQL Server.
- Selezionare Rivedi e crea.
- Al termine della convalida selezionare Crea.
Passaggio 3: il completamento della distribuzione richiede alcuni minuti. Al termine della distribuzione, selezionare il pulsante Vai alla risorsa . Si accede direttamente all'app servizio app, ma vengono create le risorse seguenti:
- Gruppo di risorse → Contenitore per tutte le risorse create.
- servizio app piano → Definisce le risorse di calcolo per servizio app. Viene creato un piano Linux nel livello Basic .
- servizio app → Rappresenta l'app ed è in esecuzione nel piano di servizio app.
- Rete virtuale → Integrata con l'app servizio app e isola il traffico di rete back-end.
- Gli endpoint privati → endpoint di Access per il server di database e la cache Redis nella rete virtuale.
- Le interfacce di rete → Rappresenta gli indirizzi IP privati, uno per ognuno degli endpoint privati.
- database SQL di Azure server → Accessibile solo da dietro l'endpoint privato.
- database SQL di Azure → database A e un utente vengono creati automaticamente nel server.
- cache di Azure per Redis → Accessibile solo da dietro l'endpoint privato.
- DNS privato zone → Abilitare la risoluzione DNS del server di database e la cache Redis nella rete virtuale.
2. Verificare i stringa di connessione
La creazione guidata ha generato stringa di connessione per il database SQL e la cache Redis già. In questo passaggio trovare le stringa di connessione generate per un secondo momento.
Passaggio 1: nella pagina servizio app selezionare Configurazione nel menu a sinistra.
Passaggio 2:
- Scorrere fino alla fine della pagina e trovare AZURE_SQL_CONNECTIONSTRING nella sezione stringhe di Connessione ion. Questa stringa è stata generata dal nuovo database SQL dalla creazione guidata. Per configurare l'applicazione, questo nome è tutto ciò di cui hai bisogno.
- Trovare anche AZURE_REDIS_CONNECTIONSTRING nella sezione Impostazioni applicazione. Questa stringa è stata generata dalla nuova cache Redis dalla creazione guidata. Per configurare l'applicazione, questo nome è tutto ciò di cui hai bisogno.
- Se si desidera, è possibile selezionare il pulsante Modifica a destra di ogni impostazione e visualizzarne o copiarne il valore.
Successivamente, si modificherà l'applicazione in modo da usare
AZURE_SQL_CONNECTIONSTRING
eAZURE_REDIS_CONNECTIONSTRING
.
3. Distribuire il codice di esempio
In questo passaggio si configurerà la distribuzione di GitHub usando GitHub Actions. È solo uno dei molti modi per eseguire la distribuzione in servizio app, ma anche un ottimo modo per avere l'integrazione continua nel processo di distribuzione. Per impostazione predefinita, ogni git push
repository GitHub avvia l'azione di compilazione e distribuzione.
Passaggio 1: In una nuova finestra del browser:
- Accedi all'account GitHub.
- Accedere a https://github.com/Azure-Samples/msdocs-app-service-sqldb-dotnetcore.
- Seleziona Fork.
- Selezionare Crea fork.
Passaggio 2: nella pagina servizio app selezionare Centro distribuzione nel menu a sinistra.
Passaggio 3: Nella pagina Centro distribuzione:
- In Origine selezionare GitHub. Per impostazione predefinita, GitHub Actions è selezionato come provider di compilazione.
- Accedere all'account GitHub e seguire la richiesta di autorizzare Azure.
- In Organizzazione selezionare l'account.
- In Repository selezionare msdocs-app-service-sqldb-dotnetcore.
- In Ramo selezionare main.
- Nel menu in alto selezionare Salva. servizio app esegue il commit di un file del flusso di lavoro nel repository GitHub scelto, nella
.github/workflows
directory .
Passaggio 4: Tornare alla pagina GitHub dell'esempio con fork, aprire Visual Studio Code nel browser premendo il .
tasto .
Passaggio 5: In Visual Studio Code nel browser:
- Aprire DotNetCoreSqlDb/appsettings.json nell'elenco delle cartelle.
- Modificare il nome
MyDbConnection
stringa di connessione inAZURE_SQL_CONNECTIONSTRING
, che corrisponde al stringa di connessione creato in servizio app precedente.
Passaggio 6:
- Aprire DotNetCoreSqlDb/Program.cs nello strumento di esplorazione.
options.UseSqlServer
Nel metodo modificare il nomeMyDbConnection
stringa di connessione inAZURE_SQL_CONNECTIONSTRING
. Questo è il punto in cui il stringa di connessione viene usato dall'applicazione di esempio.- Rimuovere il
builder.Services.AddDistributedMemoryCache();
metodo e sostituirlo con il codice seguente. Modifica il codice dall'uso di una cache in memoria alla cache Redis in Azure e lo fa usando inAZURE_REDIS_CONNECTIONSTRING
precedenza.
builder.Services.AddStackExchangeRedisCache(options =>
{
options.Configuration = builder.Configuration["AZURE_REDIS_CONNECTIONSTRING"];
options.InstanceName = "SampleInstance";
});
Passaggio 7:
- Aprire .github/workflows/main_msdocs-core-sql-XYZ in Explorer. Questo file è stato creato dalla creazione guidata servizio app.
dotnet publish
Nel passaggio aggiungere un passaggio per installare lo strumento Entity Framework Core con il comandodotnet tool install -g dotnet-ef --version 7.0.14
.- Nel nuovo passaggio aggiungere un altro passaggio per generare un bundle di migrazione del database nel pacchetto di distribuzione:
dotnet ef migrations bundle --runtime linux-x64 -p DotNetCoreSqlDb/DotNetCoreSqlDb.csproj -o ${{env.DOTNET_ROOT}}/myapp/migrate
. Il bundle di migrazione è un eseguibile autonomo che è possibile eseguire nell'ambiente di produzione senza bisogno di .NET SDK. Il contenitore linux servizio app ha solo il runtime .NET e non .NET SDK.
Passaggio 8:
- Selezionare l'estensione Controllo del codice sorgente.
- Nella casella di testo digitare un messaggio di commit come
Configure DB & Redis & add migration bundle
. - Selezionare Commit e push.
Passaggio 9: Tornare alla pagina Centro distribuzione nel portale di Azure:
- Selezionare Log. Una nuova esecuzione della distribuzione è già stata avviata dalle modifiche di cui è stato eseguito il commit.
- Nell'elemento di log per l'esecuzione della distribuzione selezionare la voce Build/Deploy Logs con il timestamp più recente.
Passaggio 10: si viene eseguiti nel repository GitHub e si noterà che l'azione GitHub è in esecuzione. Il file del flusso di lavoro definisce due fasi separate, compilare e distribuire. Attendere che l'esecuzione di GitHub mostri lo stato Completato. L'operazione richiede qualche minuto.
4. Generare lo schema del database
Con il database SQL protetto dalla rete virtuale, il modo più semplice per eseguire le migrazioni di database dotnet è in una sessione SSH con il contenitore servizio app.
Passaggio 1: Tornare alla pagina servizio app, nel menu a sinistra selezionare SSH.
Passaggio 2: Nel terminale SSH:
- Eseguire
cd /home/site/wwwroot
. Ecco tutti i file distribuiti. - Eseguire il bundle di migrazione generato dal flusso di lavoro GitHub con
./migrate
. Se ha esito positivo, servizio app si connette correttamente al database SQL. Solo le modifiche apportate ai file in/home
possono essere mantenute oltre i riavvii dell'app. Le modifiche al di fuori di/home
non sono persistenti.
5. Passare all'app
Passaggio 1: Nella pagina servizio app:
- Nel menu a sinistra selezionare Panoramica.
- Selezionare l'URL dell'app. È anche possibile passare direttamente a
https://<app-name>.azurewebsites.net
.
Passaggio 2: Aggiungere alcune attività all'elenco. Congratulazioni, si esegue un'app basata sui dati sicura ASP.NET Core nel servizio app Azure.
Suggerimento
L'applicazione di esempio implementa il modello cache-aside . Quando si visita una vista dati per la seconda volta o si ricarica la stessa pagina dopo aver apportato modifiche ai dati, il tempo di elaborazione nella pagina Web mostra un tempo molto più veloce perché carica i dati dalla cache anziché dal database.
6. Trasmettere i log di diagnostica
app Azure Servizio acquisisce tutti i messaggi registrati nella console per facilitare la diagnosi dei problemi con l'applicazione. L'app di esempio restituisce messaggi di log della console in ognuno dei relativi endpoint per illustrare questa funzionalità.
Passaggio 1: Nella pagina servizio app:
- Nel menu a sinistra selezionare servizio app log.
- In Registrazione applicazioni selezionare File System.
Passaggio 2: Dal menu a sinistra selezionare Flusso di log. Vengono visualizzati i log per l'app, inclusi i log e i log della piattaforma dall'interno del contenitore.
7. Pulire le risorse
Al termine, è possibile eliminare tutte le risorse dalla sottoscrizione di Azure eliminando il gruppo di risorse.
Passaggio 1: Nella barra di ricerca nella parte superiore del portale di Azure:
- Immettere il nome del gruppo di risorse.
- Selezionare il gruppo di risorse.
Passaggio 2: Nella pagina del gruppo di risorse selezionare Elimina gruppo di risorse.
Passaggio 3:
- Immettere il nome del gruppo di risorse per confermare l'eliminazione.
- Selezionare Elimina.
Domande frequenti
- Quanto costa questa configurazione?
- Ricerca per categorie connettersi al server database SQL di Azure protetto dietro la rete virtuale con altri strumenti?
- Come funziona lo sviluppo di app locali con GitHub Actions?
- Ricerca per categorie errori di debug durante la distribuzione di GitHub Actions?
Quanto costa questa configurazione?
I prezzi per le risorse di creazione sono i seguenti:
- Il piano di servizio app viene creato nel livello Basic e può essere ridimensionato o ridotto. Vedere Prezzi del servizio app.
- Il database SQL di Azure viene creato nel livello serverless per utilizzo generico nell'hardware della serie Standard con i core minimi. C'è un costo ridotto e può essere distribuito in altre aree. È possibile ridurre al minimo i costi riducendone le dimensioni massime oppure modificando il livello di servizio, il livello di calcolo, la configurazione hardware, il numero di core, le dimensioni del database e la ridondanza della zona. Vedere Prezzi del database SQL di Azure.
- Il cache di Azure per Redis viene creato nel livello Basic con le dimensioni minime della cache. È previsto un costo ridotto associato a questo livello. È possibile aumentare le prestazioni fino a livelli di prestazioni superiori per disponibilità, clustering e altre funzionalità più elevate. Vedere cache di Azure per Redis prezzi.
- La rete virtuale non comporta alcun addebito a meno che non si configurino funzionalità aggiuntive, ad esempio il peering. Vedere Prezzi di Azure Rete virtuale.
- La zona DNS privata comporta un piccolo addebito. Vedere Prezzi di DNS di Azure.
Ricerca per categorie connettersi al server database SQL di Azure protetto dietro la rete virtuale con altri strumenti?
- Per l'accesso di base da uno strumento da riga di comando, è possibile eseguire
sqlcmd
dal terminale SSH dell'app. Il contenitore dell'app non è disponibile consqlcmd
, quindi è necessario installarlo manualmente. Tenere presente che il client installato non persiste tra i riavvii dell'app. - Per connettersi da un client di SQL Server Management Studio o da Visual Studio, il computer deve trovarsi all'interno della rete virtuale. Ad esempio, potrebbe trattarsi di una macchina virtuale di Azure connessa a una delle subnet o di un computer in una rete locale con una connessione VPN da sito a sito con la rete virtuale di Azure.
Come funziona lo sviluppo di app locali con GitHub Actions?
Prendere il file del flusso di lavoro generato automaticamente da servizio app come esempio, ogni git push
avvia una nuova esecuzione di compilazione e distribuzione. Da un clone locale del repository GitHub si effettua il push degli aggiornamenti desiderati in GitHub. Ad esempio:
git add .
git commit -m "<some-message>"
git push origin main
Ricerca per categorie errori di debug durante la distribuzione di GitHub Actions?
Se un passaggio non riesce nel file del flusso di lavoro GitHub generato automaticamente, provare a modificare il comando non riuscito per generare un output più dettagliato. Ad esempio, è possibile ottenere più output da uno dei dotnet
comandi aggiungendo l'opzione -v
. Eseguire il commit e il push delle modifiche per attivare un'altra distribuzione per servizio app.
Passaggi successivi
Passare all'esercitazione successiva per informazioni su come proteggere l'app con un dominio e un certificato personalizzati.
In alternativa, consultare altre risorse: