Esercitazione: Pubblicare un'app ASP.NET Core e un'app Database su Azure Container Apps usando GitHub Actions

In questa esercitazione si apprenderà come distribuire un'app ASP.NET Core e un database SQL nelle app contenitore di Azure usando Visual Studio e GitHub Actions. Si apprenderà anche come gestire le migrazioni e gli aggiornamenti del database di Entity Framework in GitHub Actions, anche se i concetti possono essere applicati anche ad altri strumenti e ambienti CI/CD.

Prerequisiti

È necessario che Visual Studio 2022 sia installato con il carico di lavoro sviluppo di ASP.NET e Web e sviluppo di Azure .

Se Visual Studio è già stato installato:

Installare gli aggiornamenti più recenti in Visual Studio selezionando Guida>Per verificare la disponibilità di aggiornamenti.
Verificare che i carichi di lavoro ASP.NET e sviluppo Web e sviluppo Azure siano installati selezionando Strumenti>Get Tools and Features.

Avvertimento

Questo articolo usa le stringhe di connessione. Prestare attenzione quando si gestiscono le connessioni usando nomi utente, password o chiavi di accesso. Questi segreti non devono essere inseriti nel controllo del codice sorgente, né inseriti in posizioni non sicure in cui potrebbero essere accessibili da utenti non autorizzati. Durante lo sviluppo locale in genere ci si connette a un database locale che non richiede l'archiviazione di segreti o la connessione diretta ad Azure. Durante l'ambiente di produzione, connettersi al database SQL di Azure usando un approccio senza segreto , ad esempio Microsoft Entra ID , quando possibile.

Configurare l'app di esempio in locale

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

git clone https://github.com/Azure-Samples/msdocs-app-service-sqldb-dotnetcore.git
cd msdocs-app-service-sqldb-dotnetcore

Passare alla cartella del progetto e aprire la DotNetCoreSqlDb.sln soluzione in Visual Studio.

L'applicazione TODO è pronta per l'esecuzione, ma è necessario stabilire una connessione a localdb SQL Server disponibile in Visual Studio. Connettersi a localdb ti permetterà di eseguire l'app e mantenere i todos salvati mentre lavori in locale.

Fare clic con il pulsante destro del mouse sul nodo Servizi connessi in Esplora soluzioni di Visual Studio e scegliere Aggiungi > database DI SQL Server.
Nella finestra di dialogo Connetti alle dipendenze selezionare SQL Server Express LocalDB (locale) e quindi selezionare Avanti.
Nella finestra di dialogo Connetti a SQL Server Express LocalDB (locale) impostare i valori seguenti:
- Nome stringa di connessione: Lasciare il valore predefinito.
- Valore stringa di connessione: Lasciare il valore predefinito.
- Salvare il valore della stringa di connessione in:Selezionare Nessuno.
- Selezionare Avanti
Nella schermata Riepilogo delle modifiche lasciare le impostazioni sui valori predefiniti e selezionare Fine per completare il flusso di lavoro.

Visual Studio visualizza un riepilogo delle dipendenze del servizio, inclusa la connessione a LocalDB.

Sarà quindi necessario creare una migrazione iniziale e usarla per aggiornare il database locale con lo schema corretto per l'app TODO.

Selezionare l'icona ... a destra dell'elenco delle dipendenze del servizio accanto alla LocalDB connessione e scegliere Aggiungi migrazione.
Nella finestra di dialogo Migrazioni di Entity Framework attendere un momento in cui Visual Studio individua la DbContext classe inclusa nel progetto. Dopo aver caricato i valori, selezionare Fine.
Visual Studio genera una Migrations cartella nel progetto e crea una classe di migrazioni iniziali. Questa classe può essere usata per aggiornare il database con lo schema corretto.
Selezionare di nuovo l'icona ... accanto al LocalDB servizio e selezionare Aggiorna database.
Nella finestra di dialogo Migrazioni di Entity Framework attendere un momento in cui Visual Studio individua nuovamente la DbContext classe e quindi scegliere Fine. Visual Studio esegue la migrazione e crea lo schema per il database nel LocalDB server.

Avviare il progetto selezionando il pulsante DotNetCoreSqlDb run (Esegui DotNetCoreSqlDb ) nella parte superiore di Visual Studio.

Quando l'app viene caricata, verificare che il database funzioni correttamente immettendo un nuovo TODO. Il TODO viene visualizzato nella lista principale sulla homepage dell'app.

Esplorare la configurazione di avvio dell'app

L'app di esempio include il codice seguente nel Program.cs file:

if(builder.Environment.IsDevelopment())
{
    builder.Services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
}
else
{
    builder.Services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(Environment.GetEnvironmentVariable("AZURE_SQL_CONNECTIONSTRING")));
}

Questo codice applica le configurazioni seguenti:

Quando l'app viene eseguita in locale, la localdb stringa di connessione viene estratta dal appsettings.json file e fornita a Entity Framework. Questa configurazione consente di archiviare la localdb stringa di connessione nel controllo del codice sorgente in modo che altri sviluppatori possano connettersi facilmente a un database locale durante lo sviluppo. Consente anche l'esecuzione in locale delle migrazioni di Entity Framework. Per impostazione predefinita, Entity Framework non individua le stringhe di connessione archiviate nella variabile di ambiente durante l'esecuzione delle migrazioni.
Quando l'app viene eseguita nei flussi di lavoro di GitHub Actions o in Produzione, la stringa di connessione viene estratta dalle variabili di ambiente. Le variabili di ambiente possono impedire che le stringhe di connessione sicure di produzione vengano archiviate nel controllo del codice sorgente o incluse nei file di configurazione.

Creare i servizi di Azure

Per una distribuzione corretta, l'app richiederà la creazione dei servizi di Azure seguenti:

App contenitore: Obbligatorio per ospitare ed eseguire l'applicazione distribuita.
Registro dei Contenitori: Archivia l'artefatto dell'immagine compilata dell'app containerizzata.
Database SQL: Un database SQL di Azure per archiviare i dati dell'app.

Le funzionalità di pubblicazione di Visual Studio possono gestire automaticamente la creazione di queste risorse.

Creare l'app Azure Container e registro Azure Container

In Esplora soluzioni di Visual Studio fare clic con il pulsante destro del mouse sul nodo del progetto di primo livello e scegliere Pubblica.
Nella finestra di dialogo di pubblicazione selezionare Azure come destinazione di distribuzione e quindi selezionare Avanti.
Per la destinazione specifica, selezionare App Contenitore di Azure (Linux) e quindi selezionare Avanti.
Creare una nuova app contenitore in cui eseguire la distribuzione. Selezionare il pulsante + Crea nuovo per aprire una nuova finestra di dialogo e immettere i valori seguenti:
- 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-app-db-ef.
- Ambiente app contenitore: Selezionare Nuovo per aprire la finestra di dialogo ambiente delle app contenitore e immettere i valori seguenti:
  - Nome ambiente: Mantenere il valore predefinito.
  - Ubicazione: Selezionare una località nelle vicinanze.
  - Area di lavoro Log Analytics di Azure: Selezionare Nuovo per aprire la finestra di dialogo Area di lavoro Log Analytics.
    - Nome: Lasciare il valore predefinito.
    - Ubicazione: 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.
Dopo aver creato la risorsa, assicurarsi che sia selezionata nell'elenco delle app contenitore e quindi selezionare Avanti.
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 .
Lasciare i valori predefiniti e quindi selezionare Crea.
Dopo aver creato il registro contenitori, assicurarsi che sia selezionato e quindi selezionare Avanti.
Nella schermata Tipo di distribuzione selezionare CI/CD usando i flussi di lavoro di GitHub Actions (genera il file yml) e quindi scegliere Fine. Se Visual Studio richiede all'utente amministratore di accedere al contenitore Docker pubblicato, selezionare Sì.

Visual Studio crea e visualizza il profilo di pubblicazione. La maggior parte dei passaggi di pubblicazione e i dettagli sono descritti nel file GitHub Actions .yml , che può essere visualizzato facendo clic sul pulsante Modifica flusso di lavoro nella visualizzazione riepilogo del profilo di pubblicazione. Questo file è trattato in modo più approfondito più avanti nell'articolo.

Creare il database SQL di Azure

In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo Servizi connessi e scegliere Aggiungi > database DI SQL Server.
Nella finestra di dialogo Connetti alla dipendenza selezionare Database SQL di Azure e quindi scegliere Avanti.
Selezionare + Crea nuovo per aggiungere un nuovo database.
Nella finestra di dialogo Database SQL di Azure immettere i valori seguenti:
- Nome database: Lasciare il valore predefinito.
- Nome sottoscrizione: Selezionare la stessa sottoscrizione di in precedenza.
- Gruppo di risorse: Selezionare lo stesso msdocs-app-db-ef gruppo creato in precedenza.
- Server di database: Selezionare Nuovo e quindi immettere i valori seguenti nel nuovo POP:Select New... and then enter the following values in the new POP-up:
  - Nome server di database: Immettere un nome univoco del server o aggiungere numeri casuali alla fine del nome generato automaticamente.
  - Ubicazione: Selezionare una località vicina all'utente.
  - Nome utente amministratore: Immettere un valore scelto.
  - Password amministratore: Immettere un valore scelto.
  - Password amministratore (conferma): Immettere la stessa password da confermare. Selezionare OK per chiudere la finestra di dialogo di SQL Server
- Selezionare Crea per creare SQL Server e il database.
- Al termine dell'operazione, selezionare il server dall'elenco e scegliere Avanti
Nella finestra di dialogo Connetti al database SQL di Azure, lasciate i valori predefiniti, ma assicuratevi che l'opzione nessuno sia selezionata nella parte inferiore per Salva stringa di connessione in.
Selezionare Fine e Visual Studio creerà le risorse SQL.

Connettere l'app contenitore ad Azure SQL

Nella pagina di panoramica dell'app contenitore creata, selezionare Service Connector (anteprima) nella barra di navigazione a sinistra.
Selezionare + Crea per creare una nuova connessione.
Nel riquadro a comparsa Crea connessione immettere i valori seguenti:
- Contenitore: Selezionare il contenitore dotnetcoresqldb creato.
- Tipo di servizio: Selezionare Database SQL.
- Abbonamento: Selezionare la stessa sottoscrizione usata per creare l'app contenitore.
- Nome connessione: Lasciare il valore predefinito.
- SQL Server: Selezionare il server di database creato in precedenza.
- Database SQL: Selezionare il database creato in precedenza.
- Tipo di client: Selezionare .NET.
Selezionare Avanti: Autenticazione e immettere i valori seguenti:
- Selezionare Stringa di connessione per il tipo di autenticazione.
- Nome utente: Immettere il nome utente usato durante la creazione del server di database.
- Parola d’ordine: Immettere la password usata durante la creazione del server di database.
Lasciare le altre impostazioni predefinite e selezionare Avanti: Rete.
Lasciare selezionato il valore predefinito e scegliere Avanti: Rivedi e crea.
Dopo che Azure ha convalidato le impostazioni, seleziona Crea.

Dopo un attimo, verrà visualizzata la connessione al database SQL. Selezionare la freccia per espandere la connessione e visualizzare il valore AZURE_SQL_CONNECTIONSTRING . Questo nome di connessione corrisponde al nome della stringa di connessione della variabile di ambiente definita nell'app di esempio.

Configurare il flusso di lavoro di GitHub Actions

Il file del flusso di lavoro di GitHub Actions generato da Visual Studio può essere usato da GitHub per compilare e distribuire l'app in Azure quando viene eseguito il push delle modifiche. Attualmente questo processo funzionerebbe, ma l'app distribuita solleverà un'eccezione. Anche se il database SQL di Azure è stato creato, è necessario aggiungere un passaggio al flusso di lavoro di GitHub Actions per generare lo schema. La stringa di connessione per il database SQL di Azure può essere archiviata in modo sicuro come segreto in GitHub e recuperata dal flusso di lavoro durante l'esecuzione.

Recuperare la stringa di connessione e aggiungerla ai segreti gitHub

Nel portale di Azure cercare il database creato nella barra di ricerca principale e selezionarlo nei risultati.
Nella pagina di panoramica del database selezionare Stringhe di connessione nel menu di navigazione a sinistra.
Nella scheda ADO.NET copiare la stringa di connessione dal campo modulo.
Vai al repository GitHub forkato dell'app.
Nella scheda Impostazioni selezionare Azioni segreti > nel riquadro di spostamento a sinistra e quindi scegliere Nuovo segreto del repository.
Nella pagina Nuovo segreto immettere i valori seguenti:
- Nome: Immettere un nome di DbConnection.
- Segreto: Incollare la stringa di connessione copiata da Azure. Assicurarsi di sostituire il segnaposto della password nella stringa di connessione con la password scelta durante la creazione del database.
- Selezionare Aggiungi segreto.

La stringa di connessione viene ora archiviata in modo sicuro nei segreti del repository GitHub e può essere recuperata usando un flusso di lavoro GitHub.

Modificare il flusso di lavoro di GitHub Actions per abilitare le migrazioni

Aprire il file del flusso di lavoro .yml gitHub Actions generato da Visual Studio selezionando il pulsante Modifica flusso di lavoro nella pagina di riepilogo della pubblicazione.
Aggiungere il codice yaml seguente alla fine del file del flusso di lavoro:
```
- name: Run EF 
  run: | 
    dotnet tool install --global dotnet-ef
    dotnet tool restore
    dotnet ef database update -p DotNetCoreSqlDb --connection '${{ secrets.DBConnection }}'
```
Questo codice installa gli strumenti da riga di comando di Entity Framework ed esegue le migrazioni dell'app. Quando il flusso di lavoro viene eseguito, il codice usa anche il connection parametro del database update comando per eseguire l'override della localdb stringa di connessione archiviata nel appsettings.json file con il valore aggiunto ai segreti gitHub.

Eseguire il flusso di lavoro di GitHub Actions e testare la distribuzione

Eseguire il commit delle modifiche all'applicazione e fare push sul repository forkato usando il comando seguente:
```
git add --all
git commit -m "Added GitHub Actions workflow"
git push
```
Passare al repository GitHub e selezionare la scheda Azioni . Un'esecuzione del flusso di lavoro dovrebbe essere stata attivata automaticamente se il push ha avuto esito positivo.
Selezionare il flusso di lavoro attivo per visualizzare i dettagli del registro per ogni passaggio man mano che si completano. La migrazione viene eseguita per ultimo per aggiornare il database in Azure.

Al termine del flusso di lavoro, l'applicazione viene distribuita in App Azure Container e connessa al database con uno schema aggiornato.

È possibile testare la distribuzione passando alla home page dell'app contenitore e creando un TODO, proprio come è stato fatto in locale. È sempre possibile trovare l'URL dell'app contenitore nella pagina di panoramica dell'app nel portale di Azure.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-08-07