Containerisera en .NET Core app

Gäller för: Windows Server 2025, Windows Server 2022, Windows Server 2019, Windows Server 2016

Det här avsnittet beskriver hur du paketera en befintlig .NET-exempelapp för distribution som en Windows-container, efter att du har konfigurerat din miljö enligt beskrivningen i Kom igång: Förbereda Windows för containraroch köra din första container enligt beskrivningen i Kör din första Windows-container.

Du behöver också Git-källkontrollsystemet installerat på datorn. Om du vill installera det går du till Git.

Klona exempelkoden från GitHub

All källkod för containerexempel lagras under Virtualiseringsdokumentation git-lagringsplats i en mapp med namnet windows-container-samples.

1. Öppna en PowerShell-session och ändra kataloger till mappen där du vill lagra den här lagringsplatsen. (Andra typer av kommandotolksfönster fungerar också, men våra exempelkommandon använder PowerShell.)

2. Klona lagringsplatsen till din aktuella arbetskatalog:

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

3. Navigera till exempelkatalogen som finns under Virtualization-Documentation\windows-container-samples\asp-net-getting-started och skapa en Dockerfile med hjälp av följande kommandon.

   En Dockerfile är som en makefile – det är en lista med instruktioner som talar om för containermotorn hur containeravbildningen ska skapas.

   # 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
   

Skriv en Dockerfile

Öppna Dockerfile som du nyss skapade med vilken textredigerare du vill och lägg sedan till följande innehåll:

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"]

Nu ska vi dela upp den rad för rad och förklara vad varje instruktioner gör.

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

Den första gruppen med rader deklarerar vilken basbild vi ska använda för att skapa vår container. Om det lokala systemet inte redan har den här avbildningen försöker Docker automatiskt hämta den. mcr.microsoft.com/dotnet/core/sdk:2.1 levereras med .NET Core 2.1 SDK installerat, så det är upp till uppgiften att skapa ASP .NET Core-projekt som är inriktade på version 2.1. Nästa instruktion ändrar arbetskatalogen i containern till /app, så alla kommandon som följer den här körs i den här kontexten.

COPY *.csproj ./
RUN dotnet restore

Därefter kopierar dessa instruktioner över .csproj-filerna till build-env containerns /app-katalog. När du har kopierat den här filen läser .NET från den och går sedan ut och hämtar alla beroenden och verktyg som behövs i vårt projekt.

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

När .NET har hämtat alla beroenden till den build-env containern kopierar nästa instruktion alla projektkällfiler till containern. Sedan uppmanar vi .NET att publicera vårt program med en versionskonfiguration och ange utdatasökvägen.

Kompilering bör lyckas. Nu måste vi skapa den slutliga avbildningen.

Tips

Den här snabbstarten skapar ett .NET Core-projekt från källan. När du skapar containeravbildningar är det bra praxis att inkludera endast produktionsnyttolasten och dess beroenden i containeravbildningen. Vi vill inte att .NET Core SDK ska ingå i vår slutliga avbildning eftersom vi bara behöver .NET Core-körningen, så dockerfile skrivs för att använda en tillfällig container som är paketerad med SDK:t som heter build-env för att skapa appen.

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

Eftersom vår applikation är ASP.NET anger vi en avbild med denna runtime inkluderad. Vi kopierar sedan över alla filer från utdatakatalogen för vår tillfälliga container till vår slutliga container. Vi konfigurerar containern så att den körs med vår nya app som startpunkt när containern startar

Vi har skrivit dockerfile för att utföra en flerstegsversion. När dockerfile körs använder den den tillfälliga containern, build-env, med .NET Core 2.1 SDK för att skapa exempelappen och sedan kopiera de utdatabaserade binärfilerna till en annan container som endast innehåller .NET Core 2.1-körningen så att vi minimerar storleken på den slutliga containern.

Skapa och köra appen

När Dockerfilen är skriven kan vi peka Docker till vår Dockerfile och låta den bygga och sedan köra vår image.

1. I ett kommandotolkfönster navigerar du till katalogen där dockerfile finns och kör sedan kommandot docker build för att skapa containern från Dockerfile.

   docker build -t my-asp-app .
   

2. Kör kommandot docker för att köra den nyligen skapade containern.

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

   Nu ska vi dissekera det här kommandot:

   • -d uppmanar Docker att köra containern "fristående", vilket innebär att ingen konsol är ansluten till konsolen i containern. Containern körs i bakgrunden.
   • -p 5000:80 instruerar Docker att mappa port 5000 på värden till port 80 i containern. Varje container får sin egen IP-adress. ASP .NET lyssnar som standard på port 80. Med portmappning kan vi nå värdens IP-adress på den mappade porten, och Docker kommer att vidarebefordra all trafik direkt till den angivna porten i containern.
   • --name myapp uppmanar Docker att ge den här containern ett praktiskt namn att fråga efter (i stället för att behöva leta upp det container-ID som tilldelats vid körning av Docker).
   • my-asp-app är det image som vi vill att Docker ska köra. Det här är containeravbildningen som skapas som kulmen på docker build processen.

3. Öppna en webbläsare och gå till http://localhost:5000 för att se ditt containerbaserade program.

   

Nästa steg

1. Nästa steg är att publicera din containerbaserade ASP.NET webbapp till ett privat register med hjälp av Azure Container Registry. På så sätt kan du distribuera den i din organisation.

   Skapa ett privat containerregister

   När du kommer till avsnittet där du skjuter upp containeravbildningen till registret, anger du namnet på den ASP.NET-app som du just paketerade (my-asp-app) tillsammans med ditt containerregister (till exempel: contoso-container-registry):

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

   För att se fler appexempel och deras tillhörande dockerfiles, se ytterligare containerexempel.

2. När du har publicerat appen i containerregistret är nästa steg att distribuera appen till ett Kubernetes-kluster som du skapar med Azure Kubernetes Service.

   Skapa ett Kubernetes-kluster