Przeczytaj w języku angielskim

Udostępnij za pośrednictwem


Samouczek: konteneryzowanie aplikacji .NET

Wybieranie wersji platformy .NET

Z tego samouczka dowiesz się, jak konteneryzować aplikację platformy .NET przy użyciu platformy Docker. Kontenery mają wiele funkcji i korzyści, takich jak niezmienna infrastruktura, zapewniając przenośną architekturę i umożliwiająca skalowalność. Obraz może służyć do tworzenia kontenerów dla lokalnego środowiska deweloperskiego, chmury prywatnej lub chmury publicznej.

W tym samouczku:

  • Tworzenie i publikowanie prostej aplikacji .NET
  • Tworzenie i konfigurowanie pliku Dockerfile dla platformy .NET
  • Tworzenie obrazu platformy Docker
  • Tworzenie i uruchamianie kontenera platformy Docker

Zapoznasz się z zadaniami kompilacji i wdrażania kontenera platformy Docker dla aplikacji .NET. Platforma platform y docker używa aparatu platformy Docker do szybkiego kompilowania i tworzenia pakietów aplikacji jako obrazów platformy Docker . Te obrazy są zapisywane w formacie Dockerfile, który ma zostać wdrożony i uruchomiony w kontenerze warstwowym.

Napiwek

Jeśli interesuje Cię publikowanie aplikacji .NET jako kontenera bez konieczności używania Docker lub Podman, zobacz Konteneryzacja aplikacji .NET za pomocą polecenia dotnet publish.

Uwaga

Niniejszy samouczek nie jest przeznaczony dla aplikacji ASP.NET Core. Jeśli używasz ASP.NET Core, zobacz samouczek Dowiedz się, jak konteneryzować aplikację ASP.NET Core.

Warunki wstępne

Zainstaluj następujące wymagania wstępne:

  • .NET 8+ SDK.
    Jeśli masz zainstalowaną platformę .NET, użyj polecenia dotnet --info, aby określić, którego zestawu SDK używasz.
  • Docker Community Edition.
  • Tymczasowy folder roboczy dla przykładowej aplikacji Dockerfile i .NET. W tym samouczku nazwa docker-working jest używana jako folder roboczy.

Tworzenie aplikacji .NET

Potrzebna jest aplikacja .NET uruchomiona przez kontener platformy Docker. Otwórz terminal, utwórz folder roboczy, jeśli jeszcze tego nie zrobiono, i wprowadź go. W folderze roboczym uruchom następujące polecenie, aby utworzyć nowy projekt w podkatalogu o nazwie App:

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

Drzewo folderów wygląda podobnie do następującej struktury katalogów:

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

Polecenie dotnet new tworzy nowy folder o nazwie App i generuje aplikację konsolową "Hello World". Teraz zmienisz katalogi i przejdziesz do folderu App z sesji terminalu. Użyj polecenia dotnet run, aby uruchomić aplikację. Aplikacja działa i drukuje Hello World! poniżej polecenia:

.NET CLI
cd App
dotnet run
Hello World!

Domyślny szablon tworzy aplikację, która wyświetla dane w terminalu, a następnie natychmiast kończy działanie. W tym samouczku użyjesz aplikacji, która zapętla się w nieskończoność. Otwórz plik Program.cs w edytorze tekstów.

Napiwek

Jeśli używasz programu Visual Studio Code, z poprzedniej sesji terminalu wpisz następujące polecenie:

Console
code .

To polecenie otwiera folder App zawierający projekt w programie Visual Studio Code.

Program.cs powinien wyglądać podobnie do następującego kodu w języku C#:

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

Zastąp plik następującym kodem, który liczy liczby co sekundę:

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));
}

Zapisz plik i ponownie przetestuj program przy użyciu dotnet run. Pamiętaj, że ta aplikacja działa na czas nieokreślony. Aby go zatrzymać, użyj polecenia anuluj Ctrl+C. Rozważmy następujące przykładowe dane wyjściowe:

.NET CLI
dotnet run
Counter: 1
Counter: 2
Counter: 3
Counter: 4
^C

Jeśli przekażesz liczbę w wierszu polecenia do aplikacji, ogranicza ona liczbę do tej kwoty, a następnie kończy działanie. Spróbuj użyć dotnet run -- 5, aby zliczyć do pięciu.

Ważne

Wszystkie parametry po -- nie są przekazywane do polecenia dotnet run i zamiast tego są przekazywane do aplikacji.

Publikowanie aplikacji .NET

Aby aplikacja była odpowiednia do utworzenia obrazu, musi zostać skompilowana. Polecenie dotnet publish jest najbardziej trafne, ponieważ kompiluje i publikuje aplikację. Szczegółowe informacje można znaleźć w dokumentacji poleceń dotnet build i dotnet publish.

.NET CLI
dotnet publish -c Release

Napiwek

Jeśli interesuje Cię publikowanie aplikacji .NET jako kontenera bez konieczności korzystania z platformy Docker, zobacz Containerize a .NET app with dotnet publish.

Polecenie dotnet publish kompiluje aplikację do folderu publikacji . Ścieżka do folderu publikowania z folderu roboczego powinna być ./App/bin/Release/TFM/publish/:

Użyj polecenia ls, aby uzyskać listę katalogów i sprawdzić, czy plik DotNet.Docker.dll został utworzony.

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

Tworzenie pliku Dockerfile

Plik Dockerfile jest używany przez polecenie docker build do utworzenia obrazu kontenera. Ten plik jest plikiem tekstowym o nazwie Dockerfile, który nie ma rozszerzenia.

Utwórz plik o nazwie Dockerfile w katalogu zawierającym .csproj i otwórz go w edytorze tekstów. W tym samouczku używany jest obraz środowiska uruchomieniowego ASP.NET Core (zawierający obraz środowiska uruchomieniowego .NET) i jest zgodny z aplikacją konsolową .NET.

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

Uwaga

Obraz środowiska uruchomieniowego ASP.NET Core jest używany celowo, chociaż zamiast tego można użyć obrazu mcr.microsoft.com/dotnet/runtime:9.0.

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

Uwaga

Obraz środowiska uruchomieniowego ASP.NET Core jest używany celowo, chociaż zamiast tego można użyć obrazu mcr.microsoft.com/dotnet/runtime:8.0.

Ważne

Dołączenie bezpiecznego algorytmu wyznaczania skrótu (SHA) po tagu obrazu w dockerfile jest najlepszym rozwiązaniem. Gwarantuje to, że obraz nie zostanie naruszony i że obraz jest taki sam jak oczekiwany. Sha jest unikatowym identyfikatorem obrazu. Aby uzyskać więcej informacji, zobacz Docker Docs: pobierz obraz według skrótu.

Napiwek

W tym pliku Dockerfile są używane budowy wieloetapowe, które optymalizują ostateczny rozmiar obrazu poprzez warstwowanie budowy i pozostawienie tylko wymaganych artefaktów. Aby uzyskać więcej informacji, zobacz Docker Docs: kompilacje wieloetapowe.

Słowo kluczowe FROM wymaga w pełni kwalifikowanej nazwy obrazu kontenera platformy Docker. Microsoft Container Registry (MCR, mcr.microsoft.com) to syndykat usługi Docker Hub, który hostuje publicznie dostępne kontenery. Segment dotnet jest repozytorium kontenerów, natomiast segment sdk lub aspnet jest nazwą obrazu kontenera. Obraz jest oznaczony tagiem 9.0, który jest używany do wersjonowania. W związku z tym mcr.microsoft.com/dotnet/aspnet:9.0 jest środowiskiem uruchomieniowym platformy .NET 9.0. Upewnij się, że ściągasz wersję środowiska uruchomieniowego zgodną ze środowiskiem uruchomieniowym przeznaczonym dla zestawu SDK. Na przykład aplikacja utworzona w poprzedniej sekcji używa zestawu .NET 9.0 SDK, a obraz podstawowy, do którego odwołuje się Dockerfile, jest oznaczony tagiem 9.0.

Ważne

W przypadku używania obrazów kontenerów Windows należy określić tag obrazu innym niż 9.0, na przykład mcr.microsoft.com/dotnet/aspnet:9.0-nanoserver-1809 zamiast mcr.microsoft.com/dotnet/aspnet:9.0. Wybierz nazwę obrazu na podstawie tego, czy używasz systemu operacyjnego Nano Server, czy Windows Server Core oraz której wersji systemu operacyjnego. Pełną listę wszystkich obsługiwanych tagów można znaleźć na stronie Docker Hub platformy .NET .

Zapisz plik Dockerfile. Struktura katalogów folderu roboczego powinna wyglądać następująco. Niektóre z bardziej szczegółowych plików i folderów zostaną pominięte, aby zaoszczędzić miejsce w artykule:

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

Słowo kluczowe FROM wymaga w pełni kwalifikowanej nazwy obrazu kontenera platformy Docker. Microsoft Container Registry (MCR, mcr.microsoft.com) to syndykat usługi Docker Hub, który hostuje publicznie dostępne kontenery. Segment dotnet jest repozytorium kontenerów, natomiast segment sdk lub aspnet jest nazwą obrazu kontenera. Obraz jest oznaczony 8.0, który jest używany do kontroli wersji. W związku z tym mcr.microsoft.com/dotnet/aspnet:8.0 jest środowiskiem uruchomieniowym platformy .NET 8.0. Upewnij się, że ściągasz wersję środowiska uruchomieniowego zgodną ze środowiskiem uruchomieniowym przeznaczonym dla zestawu SDK. Na przykład aplikacja utworzona w poprzedniej sekcji używa zestawu SDK platformy .NET 8.0, a obraz podstawowy, o którym mowa w dockerfile, jest oznaczony tagiem 8.0.

Ważne

W przypadku korzystania z obrazów kontenerów opartych na systemie Windows należy określić tag obrazu bardziej szczegółowo niż tylko 8.0, na przykład mcr.microsoft.com/dotnet/aspnet:8.0-nanoserver-1809 zamiast mcr.microsoft.com/dotnet/aspnet:8.0. Wybierz nazwę obrazu na podstawie tego, czy używasz systemu operacyjnego Nano Server, czy Windows Server Core oraz której wersji systemu operacyjnego. Pełną listę wszystkich obsługiwanych tagów można znaleźć na stronie . Strona Docker Hub platformy platformy NET.

Zapisz plik Dockerfile. Struktura katalogów folderu roboczego powinna wyglądać następująco. Niektóre z bardziej szczegółowych plików i folderów zostaną pominięte, aby zaoszczędzić miejsce w artykule:

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

Instrukcje ENTRYPOINT ustawiają dotnet jako hosta dla DotNet.Docker.dll. Jednak zamiast tego można zdefiniować ENTRYPOINT jako plik wykonywalny aplikacji, opierając się na systemie operacyjnym jako hoście aplikacji:

Dockerfile
ENTRYPOINT ["./DotNet.Docker"]

Powoduje to bezpośrednie wykonanie aplikacji bez dotnet, a zamiast tego opiera się na hoście aplikacji i podstawowym systemie operacyjnym. Aby uzyskać więcej informacji na temat wdrażania plików binarnych międzyplatformowych, zobacz Tworzenie wieloplatformowego pliku binarnego.

Aby skompilować kontener, w terminalu uruchom następujące polecenie:

Console
docker build -t counter-image -f Dockerfile .

Platforma Docker przetwarza każdy wiersz w pliku Dockerfile. Polecenie . w docker build ustawia kontekst kompilacji obrazu. Przełącznik -f jest ścieżką do do pliku Dockerfile. To polecenie kompiluje obraz i tworzy lokalne repozytorium o nazwie counter-image, które wskazuje na ten obraz. Po zakończeniu tego polecenia uruchom docker images, aby wyświetlić listę zainstalowanych obrazów:

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

Repozytorium counter-image jest nazwą obrazu. Ponadto tag obrazu, identyfikator obrazu, rozmiar i czas jego utworzenia są częścią danych wyjściowych. Ostatnimi krokami Dockerfile są utworzenie kontenera z obrazu i uruchomienie aplikacji, skopiowanie aplikacji do kontenera i zdefiniowanie punktu wejścia:

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

Polecenie FROM określa obraz podstawowy i tag do użycia. Polecenie WORKDIR zmienia bieżący katalog wewnątrz kontenera na App.

Polecenie COPY informuje platformę Docker o skopiowaniu określonego katalogu źródłowego do folderu docelowego. W tym przykładzie zawartość publikowania w warstwie build są danymi wyjściowymi w folderze o nazwie App/out, więc jest to źródło do skopiowania. Cała opublikowana zawartość katalogu App/out jest kopiowana do bieżącego katalogu roboczego (App).

Następne polecenie, ENTRYPOINT, informuje platformę Docker o skonfigurowaniu kontenera do uruchomienia jako pliku wykonywalnego. Po uruchomieniu kontenera zostanie uruchomione polecenie ENTRYPOINT. Po zakończeniu tego polecenia kontener automatycznie zatrzymuje się.

Napiwek

Przed wprowadzeniem .NET 8 kontenery skonfigurowane do uruchamiania jako tylko do odczytu mogą nie działać prawidłowo z Failed to create CoreCLR, HRESULT: 0x8007000E. Aby rozwiązać ten problem, określ zmienną środowiskową DOTNET_EnableDiagnostics jako 0 (tuż przed krokiem ENTRYPOINT):

Dockerfile
ENV DOTNET_EnableDiagnostics=0

Aby uzyskać więcej informacji na temat różnych zmiennych środowiskowych platformy .NET, zobacz zmienne środowiskowe platformy .NET.

Uwaga

Program .NET 6 standaryzuje prefiks DOTNET_ zamiast COMPlus_ dla zmiennych środowiskowych, które konfigurują zachowanie środowiska uruchomieniowego .NET. Jednak prefiks COMPlus_ będzie nadal działać. Jeśli używasz poprzedniej wersji środowiska uruchomieniowego platformy .NET, nadal należy użyć prefiksu COMPlus_ dla zmiennych środowiskowych.

Tworzenie kontenera

Teraz, gdy masz obraz zawierający aplikację, możesz utworzyć kontener. Kontener można utworzyć na dwa sposoby. Najpierw utwórz nowy kontener, który jest zatrzymany.

Console
docker create --name core-counter counter-image

To polecenie docker create tworzy kontener na podstawie obrazu counter-image. Wyjście polecenia docker create pokazuje identyfikator KONTENERA kontenera (Twój identyfikator będzie inny):

Console
d0be06126f7db6dd1cee369d911262a353c9b7fb4829a0c11b4b2eb7b2d429cf

Aby wyświetlić listę wszystkich kontenerów, użyj polecenia docker ps -a:

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

Zarządzanie kontenerem

Kontener został utworzony pod określoną nazwą core-counter. Ta nazwa służy do zarządzania kontenerem. W poniższym przykładzie użyto polecenia docker start do uruchomienia kontenera, a następnie użyto polecenia docker ps, aby wyświetlić tylko uruchomione kontenery:

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

Podobnie polecenie docker stop zatrzymuje kontener. W poniższym przykładzie użyto polecenia docker stop, aby zatrzymać kontener, a następnie użyje polecenia docker ps, aby pokazać, że żadne kontenery nie są uruchomione:

Console
docker stop core-counter
core-counter

docker ps
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Nawiązywanie połączenia z kontenerem

Po uruchomieniu kontenera możesz nawiązać z nim połączenie, aby wyświetlić dane wyjściowe. Użyj poleceń docker start i docker attach, aby uruchomić kontener i zajrzeć do strumienia wyjściowego. W tym przykładzie Ctrl+C służy do odłączenia się od uruchomionego kontenera. To naciśnięcie kończy proces w kontenerze, chyba że określono inaczej, co spowoduje zatrzymanie kontenera. Parametr --sig-proxy=false gwarantuje, że Ctrl+C nie zatrzymuje procesu w kontenerze.

Po odpięciu od kontenera, podłącz go ponownie, aby sprawdzić, czy nadal działa i zlicza.

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

Usuwanie kontenera

W przypadku tego artykułu nie chcesz, aby kontenery pozostawały bezczynne. Usuń utworzony wcześniej kontener. Jeśli kontener jest uruchomiony, zatrzymaj go.

Console
docker stop core-counter

Poniższy przykład zawiera listę wszystkich kontenerów. Następnie używa polecenia docker rm do usunięcia kontenera, a następnie sprawdza drugi raz dla wszystkich uruchomionych kontenerów.

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

Pojedyncze uruchomienie

Platforma Docker udostępnia polecenie docker run służące do tworzenia i uruchamiania kontenera jako pojedynczego polecenia. To polecenie eliminuje konieczność uruchamiania docker create, a następnie docker start. Możesz również ustawić to polecenie, aby automatycznie usunąć kontener po zatrzymaniu kontenera. Na przykład użyj docker run -it --rm, aby najpierw wykonać dwie czynności, automatycznie użyj bieżącego terminalu, aby nawiązać połączenie z kontenerem, a następnie po zakończeniu kontenera usuń go:

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

Kontener przekazuje również parametry do wykonywania aplikacji .NET. Aby poinstruować aplikację .NET, aby liczyła się tylko do trzech, przekaż wartość 3.

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

W przypadku docker run -itpolecenie Ctrl+C zatrzymuje proces uruchomiony w kontenerze, co z kolei zatrzymuje kontener. Ponieważ podano parametr --rm, kontener jest automatycznie usuwany po zatrzymaniu procesu. Sprawdź, czy nie istnieje:

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

Zmienianie PUNKTU WEJŚCIA

Polecenie umożliwia również zmodyfikowanie polecenia z Dockerfile i uruchomienie czegoś innego, ale tylko dla tego kontenera. Na przykład użyj następującego polecenia, aby uruchomić bash lub cmd.exe. Edytuj polecenie zgodnie z potrzebami.

W tym przykładzie ENTRYPOINT zostanie zmieniona na bash. Polecenie exit jest uruchamiane, co kończy proces i zatrzymuje kontener.

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

Uwaga

Ten przykład działa tylko w kontenerach systemu Linux. Kontenery systemu Windows nie mają bash.

Podstawowe polecenia

Platforma Docker ma wiele różnych poleceń, które tworzą kontenery i obrazy oraz zarządzają nimi oraz współdziałają z nimi. Te polecenia platformy Docker są niezbędne do zarządzania kontenerami:

Czyszczenie zasobów

W tym samouczku utworzono kontenery i obrazy. Jeśli chcesz, usuń te zasoby. Użyj następujących poleceń, aby

  1. Wyświetlanie listy wszystkich kontenerów

    Console
    docker ps -a
    
  2. Zatrzymaj kontenery, które są uruchomione według ich nazwy.

    Console
    docker stop core-counter
    
  3. Usuwanie kontenera

    Console
    docker rm core-counter
    

Następnie usuń wszystkie obrazy, które nie są już potrzebne na maszynie. Usuń obraz stworzony za pomocą Dockerfile , a następnie usuń obraz .NET, na którym bazował Dockerfile . Możesz użyć identyfikatora obrazu lub łańcucha w formacie REPOSITORY:TAG .

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

Użyj polecenia docker images, aby wyświetlić listę zainstalowanych obrazów.

Napiwek

Pliki obrazów mogą być duże. Zazwyczaj można usunąć tymczasowe kontenery utworzone podczas testowania i tworzenia aplikacji. Zwykle przechowujesz obrazy podstawowe ze zainstalowanym środowiskiem uruchomieniowym, jeśli planujesz budowanie innych obrazów na podstawie tego środowiska.

Następne kroki