Olvasás angol nyelven

Megosztás a következőn keresztül:

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

  • Cikk
.NET-verzió kiválasztása

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:

  • Egyszerű .NET-alkalmazás létrehozása és közzététele
  • Dockerfile létrehozása és konfigurálása a .NET-hez
  • Docker-rendszerkép létrehozása
  • Docker-tároló létrehozása és futtatása

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.

Tipp.

Ha érdekli, hogy a .NET-alkalmazását konténerként tegye közzé anélkül, hogy a Docker-t vagy a Podman-t használná, tekintse meg a A .NET-alkalmazás konténerbe helyezése a dotnet publish paranccsalcímű részt.

Megjegyzés

Ez a oktatóanyag nem az ASP.NET Core alkalmazások számára készült. Ha az ASP.NET Core-t használja, tekintse meg az oktatóanyagot arról, hogyan konténerizálhat egy ASP.NET Core alkalmazást.

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:

.NET CLI 
dotnet new console -o App -n DotNet.Docker

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

Directory 
📁 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.

.NET CLI 
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.

Tipp.

Ha Visual Studio Code-ot használ, az előző terminálmunkamenetből írja be a következő parancsot:

Console 
code .

Ez a parancs megnyitja az App mappát, amely a Visual Studio Code-ban tartalmazza a projektet.

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

C# 
Console.WriteLine("Hello World!");

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

C# 
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));
}
C# 
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:

.NET CLI 
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.

Fontos

Az -- utáni paraméterek nem lesznek átadva a dotnet run parancsnak, hanem az alkalmazásnak lesznek átadva.

.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.

.NET CLI 
dotnet publish -c Release

Tipp.

Ha a .NET-alkalmazását Docker nélkül szeretné konténerként közzétenni, olvassa el a „Konténerizáljon .NET-alkalmazást a dotnet publish segítségével”című témakört.

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/:

A ls paranccsal lekérheti a címtárak listáját, és ellenőrizheti, hogy a DotNet.Docker.dll fájl létrejött-e.

Bash 
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
Bash 
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.

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

Megjegyzés

Itt szándékosan a ASP.NET Core futtatókörnyezeti rendszerképet használja a rendszer, bár ehelyett a mcr.microsoft.com/dotnet/runtime:9.0 rendszerkép használható.

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

Megjegyzés

Itt szándékosan a ASP.NET Core futtatókörnyezeti rendszerképet használja a rendszer, bár ehelyett a mcr.microsoft.com/dotnet/runtime:8.0 rendszerkép használható.

Fontos

Ajánlott eljárás, ha egy Dockerfile képcímkéje után egy biztonságos kivonatoló algoritmust (SHA) is használ. Ez biztosítja, hogy a képet ne módosítsák, és hogy a kép megegyezzen a várttal. Az SHA a kép egyedi azonosítója. További információért lásd a Docker dokumentációt: Kép lekérése kivonat alapján.

Tipp.

Ez a Dockerfile többfázisú buildeket használ, amelyek optimalizálják a rendszerkép végső méretét a build rétegzésével, és csak a szükséges összetevőket hagyják meg. További információ: Docker Docs: többfázisú buildek.

A FROM kulcsszóhoz egy teljes mértékben minősített Docker-tároló lemezképének neve szükséges. A Microsoft Container Registry (MCR, mcr.microsoft.com) a Docker Hub szindikátusa, amely nyilvánosan elérhető tárolókat üzemeltet. A dotnet szegmens a tárolóadattár, míg a sdk vagy aspnet szegmens a tárolórendszerkép neve. A kép a verziószámozáshoz használt 9.0címkével van megjelölve. Így mcr.microsoft.com/dotnet/aspnet:9.0 a .NET 9.0 futtatókörnyezet. Győződjön meg arról, hogy az SDK által megcélzott futási környezettel egyező verziót tölti le. Az előző szakaszban létrehozott alkalmazás például a .NET 9.0 SDK-t használta, és a Dockerfile hivatkozott alaprendszerkép 9.0címkével van megjelölve.

Fontos

Windows-alapú tárolórendszerképek használatakor a rendszerképcímkét a 9.0túl kell megadnia, például mcr.microsoft.com/dotnet/aspnet:9.0-nanoserver-1809mcr.microsoft.com/dotnet/aspnet:9.0helyett. Válasszon egy képnevet attól függően, hogy a Nano Servert vagy a Windows Server Core-t használja-e, és hogy az operációs rendszer melyik verzióját használja. Az összes támogatott címke teljes listája megtalálható a .NET Docker Hub oldalán.

Mentse a Dockerfile fájlt. A munkamappa könyvtárszerkezetének az alábbihoz hasonlóan kell kinéznie. A mélyebb szintű fájlok és mappák némelyike ki van hagyva a hely megtakarítása érdekében a cikkben.

Directory 
📁 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
            └──...

A FROM kulcsszóhoz egy teljes mértékben minősített Docker-tároló lemezképének neve szükséges. A Microsoft Container Registry (MCR, mcr.microsoft.com) a Docker Hub szindikátusa, amely nyilvánosan elérhető tárolókat üzemeltet. A dotnet szegmens a tárolóadattár, míg a sdk vagy aspnet szegmens a tárolórendszerkép neve. A kép a verziószámozáshoz használt 8.0címkével van megjelölve. Így mcr.microsoft.com/dotnet/aspnet:8.0 a .NET 8.0 futtatókörnyezet. Győződjön meg arról, hogy az SDK által célzott futtatókörnyezet verziójának megfelelő futtatási verziót tölti le. Az előző szakaszban létrehozott alkalmazás például a .NET 8.0 SDK-t használta, az Dockerfile hivatkozott alaprendszerkép pedig 8.0címkével van megjelölve.

Fontos

Windows-alapú tárolórendszerképek használatakor a rendszerképcímkét a 8.0túl kell megadnia, például mcr.microsoft.com/dotnet/aspnet:8.0-nanoserver-1809mcr.microsoft.com/dotnet/aspnet:8.0helyett. Válasszon egy képnevet attól függően, hogy a Nano Servert vagy a Windows Server Core-t használja-e, és hogy az operációs rendszer melyik verzióját használja. Az összes támogatott címke teljes listája megtalálható a .NET Docker Hub oldalán.

Mentse a Dockerfile fájlt. A munkamappa könyvtárszerkezetének az alábbihoz hasonlóan kell kinéznie. A cikk helymegtakarítása érdekében kihagyják a mélyebb szintű fájlok és mappák némelyikét.

Directory 
📁 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.

Dockerfile 
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:

Console 
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:

Console 
REPOSITORY       TAG       IMAGE ID       CREATED          SIZE
counter-image    latest    1c1f1433e51d   32 seconds ago   223MB
Console 
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:

Dockerfile 
FROM mcr.microsoft.com/dotnet/aspnet:9.0
WORKDIR /App
COPY --from=build /App/out .
ENTRYPOINT ["dotnet", "DotNet.Docker.dll"]
Dockerfile 
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.

Tipp.

A .NET 8 előtt az írásvédett módú futtatásra konfigurált tárolók hibát okozhatnak Failed to create CoreCLR, HRESULT: 0x8007000E. A probléma megoldásához adjon meg egy DOTNET_EnableDiagnostics környezeti változót 0 ként (a ENTRYPOINT lépés előtt):

Dockerfile 
ENV DOTNET_EnableDiagnostics=0

A különböző .NET környezeti változókkal kapcsolatos további információkért lásd .NET környezeti változókat.

Megjegyzés

A .NET 6 a .NET futásidejű viselkedést konfiguráló környezeti változók COMPlus_ helyett a DOTNET_ előtagon szabványosít. A COMPlus_ előtag azonban továbbra is működni fog. Ha a .NET-futtatókörnyezet egy korábbi verzióját használja, akkor is a környezeti változók COMPlus_ előtagját kell használnia.

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.

Console 
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):

Console 
d0be06126f7db6dd1cee369d911262a353c9b7fb4829a0c11b4b2eb7b2d429cf

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

Console 
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:

Console 
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:

Console 
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.

Console 
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.

Console 
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.

Console 
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:

Console 
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.

Console 
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:

Console 
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.

Ebben a példában a ENTRYPOINTbashlesz. A exit parancs fut, amely befejezi a folyamatot, és leállítja a tárolót.

Bash 
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

Megjegyzés

Ez a példa csak Linux-tárolókon működik. Windows-tárolók nem rendelkeznek bashelemmel.

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:

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

    Console 
    docker ps -a

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

    Console 
    docker stop core-counter

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

    Console 
    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.

Console 
docker rmi counter-image:latest
docker rmi mcr.microsoft.com/dotnet/aspnet:9.0
Console 
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.

Tipp.

A képfájlok nagy méretűek lehetnek. Általában eltávolítaná az alkalmazás tesztelése és fejlesztése során létrehozott ideiglenes tárolókat. Az alaprendszerképeket általában a futtatókörnyezettel együtt kell tárolnia, ha az adott futtatókörnyezet alapján más rendszerképeket szeretne készíteni.

Következő lépések