Oktatóanyag: .NET-alkalmazás tárolóba helyezése

Ebben az oktatóanyagban megtudhatja, hogyan tárolózhat egy .NET-alkalmazást a Dockerrel. A tárolók számos funkcióval és előnnyel rendelkeznek, például nem módosítható infrastruktúra, hordozható architektúrát biztosítanak, és lehetővé teszik a méretezhetőséget. A rendszerkép segítségével tárolókat hozhat létre a helyi fejlesztési környezethez, a magánfelhőhöz vagy a nyilvános felhőhöz.

Ebben az oktatóanyagban ön:

Megismerheti a Docker-tárolók .NET-alkalmazásokhoz készült buildelési és üzembe helyezési feladatait. A Docker platform a Docker-engine használatával gyorsan készíthet és csomagolhat alkalmazásokat Docker image. Ezek a képek Dockerfile formátumban vannak megírva, és rétegzett tárolóban futtathatók.

Előfeltételek

Telepítse a következő előfeltételeket:

• .NET 8+ SDK.
  Ha telepítve van a .NET, a dotnet --info paranccsal állapítsa meg, hogy melyik SDK-t használja.
• Docker Community Edition.
• Ideiglenes munkamappa a Dockerfile és .NET-példaalkalmazáshoz. Ebben az oktatóanyagban a docker-working nevet használjuk munkamappaként.

.NET-alkalmazás létrehozása

Szüksége van egy .NET-alkalmazásra, amelyet a Docker-tároló futtat. Nyissa meg a terminált, hozzon létre egy munkamappát, ha még nem tette meg, és írja be. A munkamappában futtassa a következő parancsot egy új projekt létrehozásához egy Appnevű alkönyvtárban:

dotnet new console -o App -n DotNet.Docker

A mappafa a következő könyvtárszerkezethez hasonlóan néz ki:

📁 docker-working
    └──📂 App
        ├──DotNet.Docker.csproj
        ├──Program.cs
        └──📂 obj
            ├── DotNet.Docker.csproj.nuget.dgspec.json
            ├── DotNet.Docker.csproj.nuget.g.props
            ├── DotNet.Docker.csproj.nuget.g.targets
            ├── project.assets.json
            └── project.nuget.cache

A dotnet new parancs létrehoz egy új mappát App néven, és létrehoz egy "Hello World" konzolalkalmazást. Most módosíthatja a könyvtárakat, és a terminálmunkamenetből navigálhat a Alkalmazás mappába. Az alkalmazás elindításához használja a dotnet run parancsot. Az alkalmazás fut, és kinyomtatja a Hello World!-at a parancs alatt.

cd App
dotnet run
Hello World!

Az alapértelmezett sablon létrehoz egy alkalmazást, amely a terminálon nyomtat, majd azonnal leáll. Ebben az oktatóanyagban egy végtelenül ismétlődő alkalmazást használ. Nyissa meg a Program.cs fájlt egy szövegszerkesztőben.

code .

A Program.cs a következő C#-kódhoz hasonlóan kell kinéznie:

Console.WriteLine("Hello World!");

Cserélje le a fájlt a következő kódra, amely másodpercenként számokat számol:

var counter = 0;
var max = args.Length is not 0 ? Convert.ToInt32(args[0]) : -1;

while (max is -1 || counter < max)
{
    Console.WriteLine($"Counter: {++counter}");

    await Task.Delay(TimeSpan.FromMilliseconds(1_000));
}

var counter = 0;
var max = args.Length is not 0 ? Convert.ToInt32(args[0]) : -1;

while (max is -1 || counter < max)
{
    Console.WriteLine($"Counter: {++counter}");

    await Task.Delay(TimeSpan.FromMilliseconds(1_000));
}

Mentsd a fájlt, és teszteld újra a programot a dotnet runsegítségével. Ne feledje, hogy ez az alkalmazás határozatlan ideig fut. Használja a mégse parancsot a Ctrl+C kombinációja leállítására. Vegye figyelembe a következő példakimenetet:

dotnet run
Counter: 1
Counter: 2
Counter: 3
Counter: 4
^C

Ha egy számot ad át a parancssorban az alkalmazásnak, az erre az összegre korlátozza a számot, majd kilép. Próbálja ki a dotnet run -- 5 kóddal, hogy ötig számoljon.

.NET-alkalmazás közzététele

Ahhoz, hogy az alkalmazás alkalmas legyen egy kép létrehozására, össze kell állítania. Ehhez a dotnet publish parancs a legalkalmasabb, mivel létrehozza és közzéteszi az alkalmazást. Részletesebb információért lásd a dotnet build és dotnet publish parancsok dokumentációját.

dotnet publish -c Release

A dotnet publish utasítás az alkalmazást a publikálási mappába fordítja. Az elérési út a munkamappából a közzétételi mappához: ./App/bin/Release/<TFM>/publish/:

dir .\bin\Release\net9.0\publish\

    Directory: C:\Users\default\docker-working\App\bin\Release\net9.0\publish

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----          1/6/2025  10:11 AM            431 DotNet.Docker.deps.json
-a----          1/6/2025  10:11 AM           6144 DotNet.Docker.dll
-a----          1/6/2025  10:11 AM         145408 DotNet.Docker.exe
-a----          1/6/2025  10:11 AM          11716 DotNet.Docker.pdb
-a----          1/6/2025  10:11 AM            340 DotNet.Docker.runtimeconfig.json

dir .\bin\Release\net8.0\publish\

    Directory: C:\Users\default\docker-working\App\bin\Release\net8.0\publish

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a---           9/22/2023  9:17 AM            431 DotNet.Docker.deps.json
-a---           9/22/2023  9:17 AM           6144 DotNet.Docker.dll
-a---           9/22/2023  9:17 AM         157696 DotNet.Docker.exe
-a---           9/22/2023  9:17 AM          11688 DotNet.Docker.pdb
-a---           9/22/2023  9:17 AM            353 DotNet.Docker.runtimeconfig.json

me@DESKTOP:/docker-working/app$ ls bin/Release/net9.0/publish
DotNet.Docker.deps.json  DotNet.Docker.dll  DotNet.Docker.exe  DotNet.Docker.pdb  DotNet.Docker.runtimeconfig.json

me@DESKTOP:/docker-working/app$ ls bin/Release/net8.0/publish
DotNet.Docker.deps.json  DotNet.Docker.dll  DotNet.Docker.exe  DotNet.Docker.pdb  DotNet.Docker.runtimeconfig.json

A Dockerfile létrehozása

A Dockerfile fájlt a docker build parancs használja tárolólemezkép létrehozásához. Ez a fájl Dockerfile nevű szövegfájl, amely nem rendelkezik kiterjesztéssel.

Hozzon létre egy Dockerfile nevű fájlt a .csproj tartalmazó könyvtárban, és nyissa meg egy szövegszerkesztőben. Ez az oktatóanyag a ASP.NET Core futtatókörnyezeti rendszerképet használja (amely tartalmazza a .NET-futtatókörnyezet rendszerképét), és megfelel a .NET-konzolalkalmazásnak.

FROM mcr.microsoft.com/dotnet/sdk:9.0@sha256:3fcf6f1e809c0553f9feb222369f58749af314af6f063f389cbd2f913b4ad556 AS build
WORKDIR /App

# Copy everything
COPY . ./
# Restore as distinct layers
RUN dotnet restore
# Build and publish a release
RUN dotnet publish -o out

# Build runtime image
FROM mcr.microsoft.com/dotnet/aspnet:9.0@sha256:b4bea3a52a0a77317fa93c5bbdb076623f81e3e2f201078d89914da71318b5d8
WORKDIR /App
COPY --from=build /App/out .
ENTRYPOINT ["dotnet", "DotNet.Docker.dll"]

FROM mcr.microsoft.com/dotnet/sdk:8.0@sha256:35792ea4ad1db051981f62b313f1be3b46b1f45cadbaa3c288cd0d3056eefb83 AS build
WORKDIR /App

# Copy everything
COPY . ./
# Restore as distinct layers
RUN dotnet restore
# Build and publish a release
RUN dotnet publish -o out

# Build runtime image
FROM mcr.microsoft.com/dotnet/aspnet:8.0@sha256:6c4df091e4e531bb93bdbfe7e7f0998e7ced344f54426b7e874116a3dc3233ff
WORKDIR /App
COPY --from=build /App/out .
ENTRYPOINT ["dotnet", "DotNet.Docker.dll"]

📁 docker-working
    └──📂 App
        ├── Dockerfile
        ├── DotNet.Docker.csproj
        ├── Program.cs
        ├──📂 bin
        │   └───📂 Release
        │        └───📂 net9.0
        │             ├───📂 publish
        │             │    ├─── DotNet.Docker.deps.json
        │             │    ├─── DotNet.Docker.dll
        │             │    ├─── DotNet.Docker.exe
        │             │    ├─── DotNet.Docker.pdb
        │             │    └─── DotNet.Docker.runtimeconfig.json
        │             ├─── DotNet.Docker.deps.json
        │             ├─── DotNet.Docker.dll
        │             ├─── DotNet.Docker.exe
        │             ├─── DotNet.Docker.pdb
        │             └─── DotNet.Docker.runtimeconfig.json
        └──📁 obj
            └──...

📁 docker-working
    └──📂 App
        ├── Dockerfile
        ├── DotNet.Docker.csproj
        ├── Program.cs
        ├──📂 bin
        │   └──📂 Release
        │       └──📂 net8.0
        │           └──📂 publish
        │               ├── DotNet.Docker.deps.json
        │               ├── DotNet.Docker.exe
        │               ├── DotNet.Docker.dll
        │               ├── DotNet.Docker.pdb
        │               └── DotNet.Docker.runtimeconfig.json
        └──📁 obj
            └──...

A ENTRYPOINT utasítás beállítja dotnet-et a DotNet.Docker.dllgazdagépeként. Azonban lehetséges, hogy a ENTRYPOINT az alkalmazás végrehajtható fájlként legyen definiálva, az operációs rendszerre támaszkodva, mint az alkalmazás gazdája.

ENTRYPOINT ["./DotNet.Docker"]

Ez azt eredményezi, hogy az alkalmazás közvetlenül, dotnetnélkül lesz végrehajtva, és ehelyett az alkalmazás gazdagépére és az alapul szolgáló operációs rendszerre támaszkodik. A platformfüggetlen bináris fájlok üzembe helyezéséről további információt Platformfüggetlen binárislétrehozása című témakörben talál.

A tároló létrehozásához futtassa a következő parancsot a terminálból:

docker build -t counter-image -f Dockerfile .

A Docker a Dockerfileminden sorát feldolgozza. A . a docker build parancsban beállítja a rendszerkép építési környezetét. A -f kapcsoló a Dockerfileelérési útja. Ez a parancs létrehozza a képfájlt, és létrehoz egy helyi adattárat számlálókép, amely erre a képfájlra hivatkozik. A parancs befejeződése után futtassa a docker images a telepített képek listájának megtekintéséhez:

REPOSITORY       TAG       IMAGE ID       CREATED          SIZE
counter-image    latest    1c1f1433e51d   32 seconds ago   223MB

docker images
REPOSITORY       TAG       IMAGE ID       CREATED          SIZE
counter-image    latest    2f15637dc1f6   10 minutes ago   217MB

A counter-image adattár a kép neve. Emellett a képcímke, a képazonosító, a méret és a létrehozásuk is a kimenet részét képezi. A Dockerfile utolsó lépéseként hozzon létre egy tárolót a rendszerképből, futtassa az alkalmazást, másolja a közzétett alkalmazást a tárolóba, és határozza meg a belépési pontot:

FROM mcr.microsoft.com/dotnet/aspnet:9.0
WORKDIR /App
COPY --from=build /App/out .
ENTRYPOINT ["dotnet", "DotNet.Docker.dll"]

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /App
COPY --from=build /App/out .
ENTRYPOINT ["dotnet", "DotNet.Docker.dll"]

A FROM parancs megadja a használni kívánt alaprendszerképet és címkét. A WORKDIR parancs a tárolón belüli jelenlegi könyvtáratAlkalmazás.

A COPY parancs arra utasítja a Dockert, hogy másolja a megadott forráskönyvtárat egy célmappába. Ebben a példában a közzéteszi a tartalmakat a build rétegen, amelyeket a Alkalmazás/kinevű mappába kerülnek, így ez lesz a forrás, ahonnan másolni kell. A Alkalmazás/ki könyvtárban közzétett összes tartalom át lesz másolva az aktuális munkakönyvtárba (Alkalmazás).

A következő parancs, ENTRYPOINT, arra utasítja a Dockert, hogy konfigurálja a tárolót végrehajthatóként való futtatásra. A tároló indításakor a ENTRYPOINT parancs fut. Ha ez a parancs véget ér, a tároló automatikusan leáll.

ENV DOTNET_EnableDiagnostics=0

Tároló létrehozása

Most, hogy már rendelkezik az alkalmazást tartalmazó képpel, létrehozhat egy tárolót. Tárolót kétféleképpen hozhat létre. Először hozzon létre egy leállított új tárolót.

docker create --name core-counter counter-image

Ez a docker create parancs létrehoz egy tárolót a ellenképkép kép alapján. A parancs kimenete a tároló tárolóazonosítóját jeleníti meg (az azonosító eltérő lesz):

d0be06126f7db6dd1cee369d911262a353c9b7fb4829a0c11b4b2eb7b2d429cf

Az összes tároló listájának megtekintéséhez használja a parancsot:

docker ps -a
CONTAINER ID   IMAGE           COMMAND                  CREATED          STATUS    PORTS     NAMES
d0be06126f7d   counter-image   "dotnet DotNet.Docke…"   12 seconds ago   Created             core-counter

A tároló kezelése

A core-counternevű tároló lett létrehozva. Ez a név a tároló kezelésére szolgál. Az alábbi példa a docker start paranccsal indítja el a tárolót, majd a docker ps paranccsal csak a futó tárolókat jeleníti meg:

docker start core-counter
core-counter

docker ps
CONTAINER ID   IMAGE           COMMAND                  CREATED          STATUS          PORTS     NAMES
cf01364df453   counter-image   "dotnet DotNet.Docke…"   53 seconds ago   Up 10 seconds             core-counter

Hasonlóképpen, a docker stop parancs leállítja a tárolót. Az alábbi példa a docker stop paranccsal állítja le a tárolót, majd a docker ps paranccsal mutatja, hogy nincsenek tárolók:

docker stop core-counter
core-counter

docker ps
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Csatlakozás tárolóhoz

A tároló futtatása után csatlakozhat hozzá a kimenet megtekintéséhez. A docker start és docker attach parancsokkal indítsa el a tárolót, és nézze meg a kimeneti adatfolyamot. Ebben a példában a Ctrl+C billentyűkombinációval választja el a futó tárolót. Ez a billentyűleütés a tárolóban befejezi a folyamatot, hacsak nincs másként megadva, ami leállítja a tárolót. A paraméter biztosítja, hogy a Ctrl+C ne állítsa le a folyamatot a tárolóban.

Miután leválasztotta a tárolót, csatlakozzon újra, hogy ellenőrizze, még mindig fut-e és számol-e.

docker start core-counter
core-counter

docker attach --sig-proxy=false core-counter
Counter: 7
Counter: 8
Counter: 9
^C

docker attach --sig-proxy=false core-counter
Counter: 17
Counter: 18
Counter: 19
^C

Tároló törlése

Ehhez a cikkhez nem akar olyan tárolókat, amelyek nem csinálnak semmit. Törölje a korábban létrehozott tárolót. Ha a tároló fut, állítsa le.

docker stop core-counter

Az alábbi példa az összes tárolót felsorolja. Ezután a docker rm paranccsal törli a tárolót, majd másodszor ellenőrzi a futó tárolókat.

docker ps -a
CONTAINER ID    IMAGE            COMMAND                   CREATED          STATUS                        PORTS    NAMES
2f6424a7ddce    counter-image    "dotnet DotNet.Dock…"    7 minutes ago    Exited (143) 20 seconds ago            core-counter

docker rm core-counter
core-counter

docker ps -a
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Egyszeri futtatás

A Docker biztosítja a docker run parancsot a tároló egyetlen parancsként való létrehozásához és futtatásához. Ez a parancs szükségtelenné teszi a docker create, majd docker startfuttatását. Ezt a parancsot úgy is beállíthatja, hogy a tároló leállásakor automatikusan törölje a tárolót. Például a docker run -it --rm használatával két dolgot hajthat végre, először automatikusan használja az aktuális terminált a tárolóhoz való csatlakozáshoz, majd amikor a tároló befejeződik, távolítsa el:

docker run -it --rm counter-image
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
^C

A tároló a paramétereket is átadja a .NET-alkalmazás végrehajtásához. Ha azt szeretné, hogy a .NET-alkalmazás csak háromra számoljon, adja meg a 3-at.

docker run -it --rm counter-image 3
Counter: 1
Counter: 2
Counter: 3

A esetén a Ctrl+C parancs leállítja a tárolóban futó folyamatot, amely viszont leállítja a tárolót. Mivel a --rm paraméter meg lett adva, a tároló automatikusan törlődik a folyamat leállításakor. Ellenőrizze, hogy nem létezik-e:

docker ps -a
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Az ENTRYPOINT módosítása

A docker run parancs lehetővé teszi a DockerfileENTRYPOINT parancsának módosítását, és más parancs futtatását is lehetővé teszi, de csak az adott tárolóhoz. A következő paranccsal például futtathatja bash vagy cmd.exe. Szükség szerint szerkessze a parancsot.

docker run -it --rm --entrypoint "cmd.exe" counter-image

Microsoft Windows [Version 10.0.17763.379]
(c) 2018 Microsoft Corporation. All rights reserved.

C:\>dir
 Volume in drive C has no label.
 Volume Serial Number is 3005-1E84

 Directory of C:\

04/09/2019  08:46 AM    <DIR>          app
03/07/2019  10:25 AM             5,510 License.txt
04/02/2019  01:35 PM    <DIR>          Program Files
04/09/2019  01:06 PM    <DIR>          Users
04/02/2019  01:35 PM    <DIR>          Windows
               1 File(s)          5,510 bytes
               4 Dir(s)  21,246,517,248 bytes free

C:\>^C

docker run -it --rm --entrypoint "bash" counter-image
root@9f8de8fbd4a8:/App# ls
DotNet.Docker  DotNet.Docker.deps.json  DotNet.Docker.dll  DotNet.Docker.pdb  DotNet.Docker.runtimeconfig.json
root@9f8de8fbd4a8:/App# dotnet DotNet.Docker.dll 7
Counter: 1
Counter: 2
Counter: 3
^C
root@9f8de8fbd4a8:/App# exit
exit

Alapvető parancsok

A Docker számos különböző parancsot tartalmaz, amelyek tárolókat és képfájlokat hoznak létre, kezelnek és azokkal dolgoznak. Ezek a Docker-parancsok nélkülözhetetlenek a tárolók kezeléséhez:

• Docker buildelési
• Docker futtatása
• docker ps
• docker leállítása
• docker rm
• docker rmi
• Docker-rendszerkép

Erőforrások törlése

Ebben az oktatóanyagban tárolókat és képfájlokat hozott létre. Ha szeretné, törölje ezeket az erőforrásokat. Az alábbi parancsokkal

1. Az összes tároló listázása

   docker ps -a
   

2. Állítsa le a nevük alapján futó tárolókat.

   docker stop core-counter
   

3. A tároló törlése

   docker rm core-counter
   

Ezután törölje azokat a képeket, amelyeket már nem szeretne a gépén. Törölje a Dockerfile által létrehozott képet, majd törölje azt a .NET-lemezképet, amelyen Dockerfile alapult. Használhatja a képazonosító vagy a REPOSITORY:TAG formázott karakterláncot.

docker rmi counter-image:latest
docker rmi mcr.microsoft.com/dotnet/aspnet:9.0

docker rmi counter-image:latest
docker rmi mcr.microsoft.com/dotnet/aspnet:8.0

A docker images paranccsal megtekintheti a telepített képek listáját.

Következő lépések

• .NET-alkalmazás tárolóba helyezése dotnet közzétételi
• .NET-tárolórendszerképek
• ASP.NET Core-alkalmazás tárolóba helyezése
• tárolókat támogató Azure-szolgáltatások
• Dockerfile-parancsok
• Konténer eszközök a Visual Studio-hoz