Containerizzare un'app .NET Core

Si applica a: Windows Server 2025, Windows Server 2022, Windows Server 2019, Windows Server 2016

Questo argomento descrive come creare un pacchetto di un'app .NET di esempio esistente per la distribuzione come contenitore di Windows, dopo aver configurato l'ambiente come descritto in Primi passi: prepara Windows per i contenitorie dopo aver eseguito il primo contenitore come descritto in Eseguire il primo contenitore di Windows.

È necessario anche il sistema di controllo del codice sorgente Git installato nel computer. Per installarlo, visitare Git.

Clonare il codice di esempio da GitHub

Tutto il codice sorgente di esempio del contenitore viene mantenuto nel repository Git Virtualization-Documentation in una cartella denominata windows-container-samples.

1. Aprire una sessione di PowerShell e passare alla cartella in cui archiviare il repository. Anche altri tipi di finestra del prompt dei comandi funzionano, ma i comandi di esempio usano PowerShell.

2. Clonare il repository nella directory di lavoro corrente:

   git clone https://github.com/MicrosoftDocs/Virtualization-Documentation.git
   

3. Passare alla directory di esempio disponibile in Virtualization-Documentation\windows-container-samples\asp-net-getting-started e creare un Dockerfile usando i comandi seguenti.

   Un Dockerfile è simile a un makefile. Si tratta di un elenco di istruzioni che indicano al motore del contenitore come compilare l'immagine del contenitore.

   # Navigate into the sample directory
   Set-Location -Path Virtualization-Documentation\windows-container-samples\asp-net-getting-started
   
   # Create the Dockerfile for our project
   New-Item -Name Dockerfile -ItemType file
   

Scrivere il Dockerfile

Aprire il Dockerfile appena creato con l'editor di testo desiderato e quindi aggiungere il contenuto seguente:

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "asp-net-getting-started.dll"]

Di seguito viene illustrato come suddividere la riga per riga e spiegare le operazioni che ogni istruzione esegue.

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build-env
WORKDIR /app

Il primo gruppo di righe dichiara quale immagine di base verrà utilizzata per costruire il nostro contenitore. Se il sistema locale non ha già questa immagine, docker proverà automaticamente a recuperarlo. Il mcr.microsoft.com/dotnet/core/sdk:2.1 viene fornito con il .NET Core 2.1 SDK installato, quindi è in grado di creare progetti ASP .NET Core con obiettivo la versione 2.1. L'istruzione successiva modifica la directory di lavoro nel contenitore in modo che sia /app, quindi tutti i comandi successivi a questo vengono eseguiti in questo contesto.

COPY *.csproj ./
RUN dotnet restore

Queste istruzioni copiano quindi i file con estensione csproj nella directory /app del contenitore build-env. Dopo aver copiato questo file, .NET lo leggerà e procederà al recupero di tutte le dipendenze e gli strumenti necessari per il progetto.

COPY . ./
RUN dotnet publish -c Release -o out

Dopo che .NET ha eseguito il pull di tutte le dipendenze nel contenitore build-env, l'istruzione successiva copia tutti i file di origine del progetto nel contenitore. Verrà quindi indicato a .NET di pubblicare l'applicazione con una configurazione di versione e specificare il percorso di output.

La compilazione avrà esito positivo. A questo punto è necessario creare l'immagine finale.

Suggerimento

Questa guida introduttiva compila un progetto .NET Core dal codice sorgente. Quando si compilano immagini del container, è consigliabile includere solo il carico utile di produzione e le sue dipendenze nell'immagine del container. Non si vuole che .NET Core SDK sia incluso nell'immagine finale perché è necessario solo il runtime .NET Core, quindi il dockerfile viene scritto per usare un contenitore temporaneo incluso nell'SDK denominato build-env per compilare l'app.

FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "asp-net-getting-started.dll"]

Poiché l'applicazione è ASP.NET, viene specificata un'immagine con questo runtime incluso. Copiare quindi tutti i file dalla directory di output del contenitore temporaneo nel contenitore finale. Configuriamo il nostro contenitore in modo che esegua la nostra nuova app come punto di ingresso all'avvio del contenitore

Il dockerfile è stato scritto per eseguire un compilazione a più fasi. Quando viene eseguito il dockerfile, usa il contenitore temporaneo, build-env, con .NET Core 2.1 SDK per compilare l'app di esempio e quindi copiare i file binari restituiti in un altro contenitore contenente solo il runtime .NET Core 2.1 in modo da ridurre al minimo le dimensioni del contenitore finale.

Compilare ed eseguire l'app

Con il Dockerfile redatto, possiamo indicare a Docker il Dockerfile e istruirlo a costruire e quindi eseguire l'immagine.

1. In una finestra del prompt dei comandi passare alla directory in cui risiede il dockerfile e quindi eseguire il comando docker build per compilare il contenitore dal Dockerfile.

   docker build -t my-asp-app .
   

2. Per eseguire il contenitore appena compilato, eseguire il comando docker run.

   docker run -d -p 5000:80 --name myapp my-asp-app
   

   Esaminiamo questo comando:

   • -d indica a Docker di eseguire il contenitore in modalità "detached", ovvero nessuna console viene collegata alla console all'interno del contenitore. Il contenitore viene eseguito in secondo piano.
   • -p 5000:80 indica a Docker di eseguire il mapping della porta 5000 nell'host alla porta 80 nel contenitore. Ogni contenitore ottiene il proprio indirizzo IP. ASP .NET ascolta sulla porta 80 per impostazione predefinita. Il mappaggio delle porte permette di accedere all'indirizzo IP dell'host sulla porta mappata, e Docker inoltra tutto il traffico alla porta di destinazione all'interno del contenitore.
   • --name myapp indica a Docker di assegnare a questo contenitore un nome pratico per eseguire una query, invece di dover cercare l'ID contenitore assegnato in fase di esecuzione da Docker.
   • my-asp-app è l'immagine che vogliamo eseguire con Docker. Si tratta dell'immagine del contenitore prodotta come culminante del processo di docker build.

3. Aprire un Web browser e passare a http://localhost:5000 per visualizzare l'applicazione in contenitori.

   

Passaggi successivi

1. Il passaggio successivo consiste nel pubblicare l'app Web in contenitori ASP.NET in un registro privato usando Registro Azure Container. In questo modo è possibile distribuirlo nell'organizzazione.

   Creare un registro contenitori privato

   Quando si arriva alla sezione in cui si eseguire il push dell'immagine del contenitore nel registro, specificare il nome dell'app ASP.NET appena inserita nel pacchetto (my-asp-app) insieme al registro contenitori ( ad esempio: contoso-container-registry):

   docker tag my-asp-app contoso-container-registry.azurecr.io/my-asp-app:v1
   

   Per visualizzare altri esempi di app e i relativi dockerfile associati, vedere altri esempi di contenitori.

2. Dopo aver pubblicato l'app nel registro contenitori, il passaggio successivo consiste nel distribuire l'app in un cluster Kubernetes creato con il servizio Azure Kubernetes.

   Creare un cluster Kubernetes