Esercitazione: Distribuire un'app core di ASP.NET e un database in app contenitore di Azure usando GitHub Actions

Articolo
11/03/2023

In questa esercitazione si apprenderà come distribuire un'app ASP.NET Core e database SQL in 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 ?>Controlla aggiornamenti.
Verificare che i carichi di lavoro ASP.NET e sviluppo Web e sviluppo di Azure siano installati selezionando Strumenti Ottieni strumenti>e funzionalità.

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 al localdb server SQL disponibile in Visual Studio. Connessione a localdb consentirà di eseguire l'app e rendere persistenti i todos durante l'uso in locale.

Fare clic con il pulsante destro del mouse sul nodo Servizi Connessione in Esplora soluzioni di Visual Studio e scegliere Aggiungi > database SQL Server.
Nella finestra di dialogo Connessione alle dipendenze selezionare SQL Server Express Local DB (locale) e quindi selezionare Avanti.
Nella finestra di dialogo Connessione su SQL Server Express Local DB (locale) impostare i valori seguenti:
- nome stringa Connessione ion: lasciare il valore predefinito.
- valore stringa Connessione ion: lasciare il valore predefinito.
- Salva stringa di connessione valore 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 visualizzazione elenco principale nella home page 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, il localdb stringa di connessione viene estratto dal appsettings.json file e fornito a Entity Framework. Questa configurazione consente di archiviare i 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 stringa 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, il stringa di connessione viene estratto dalle variabili di ambiente. Le variabili di ambiente possono impedire che le stringa 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 Contenitori: archivia l'artefatto dell'immagine compilata dell'app in contenitori.
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 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.
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 di abilitare l'utente Amministrazione ad 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 Connessione ed e scegliere Aggiungi > database DI SQL Server.
Nella finestra di dialogo Connessione alle dipendenze 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 precedente.
- 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 popup:
  - Nome server di database: immettere un nome server univoco o aggiungere numeri casuali alla fine del nome generato automaticamente.
  - Località: scegliere una località vicina.
  - nome utente Amministrazione istrator: immettere un valore scelto.
  - Amministrazione istrator password: immettere un valore scelto.
  - Amministrazione istrator password (conferma): immettere la stessa password da confermare. Selezionare OK per chiudere la finestra di dialogo di SQL Server
- Selezionare Crea per creare il server SQL e il database.
- Al termine dell'operazione, selezionare il server dall'elenco e scegliere Avanti
Nella finestra di dialogo Connessione da database SQL di Azure lasciare i valori predefiniti, ma assicurarsi che Nessuno sia selezionato nella parte inferiore per l'opzione Salva stringa di connessione valore in .
Selezionare Fine e Visual Studio creerà le risorse SQL.

Connessione l'app contenitore in Azure SQL

Nella pagina di panoramica dell'app contenitore creata selezionare Service Connessione or (anteprima) nel riquadro di spostamento 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.
- Sottoscrizione: selezionare la stessa sottoscrizione usata per creare l'app contenitore.
- nome Connessione ion: 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 Connessione stringa di autenticazione per il tipo di autenticazione.
- Nome utente: immettere il nome utente usato durante la creazione del server di database.
- Password: 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 la convalida di Azure, le impostazioni selezionare 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 variabile di ambiente stringa di connessione 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 funziona, ma l'app distribuita genererà 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. Il stringa di connessione per il database SQL di Azure può essere archiviato in modo sicuro come segreto in GitHub e recuperato dal flusso di lavoro durante l'esecuzione.

Recuperare il stringa di connessione e aggiungerlo ai segreti di GitHub

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

Il stringa di connessione viene ora archiviato in modo sicuro nei segreti del repository GitHub e può essere recuperato 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 comando per eseguire l'override del database updatelocaldb stringa di connessione archiviato 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 ed eseguire il push nel repository con fork 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 log per ogni passaggio al termine. 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.

Condividi tramite