Samouczek: konteneryzowanie aplikacji .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:

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.

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:

dotnet new console -o App -n DotNet.Docker

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

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

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.

code .

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

Console.WriteLine("Hello World!");

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

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

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:

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.

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.

dotnet publish -c Release

Polecenie dotnet publish kompiluje aplikację do folderu publikacji . Ścieżka do folderu publikowania z folderu roboczego powinna być ./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

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.

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

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:

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:

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:

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

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:

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

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

ENV DOTNET_EnableDiagnostics=0

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.

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

d0be06126f7db6dd1cee369d911262a353c9b7fb4829a0c11b4b2eb7b2d429cf

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

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:

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:

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.

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.

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.

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:

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.

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:

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.

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

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:

• kompilacji platformy Docker
• docker run
• docker ps
• zatrzymanie Docker
• docker rm
• docker rmi
• obraz Docker

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

   docker ps -a
   

2. Zatrzymaj kontenery, które są uruchomione według ich nazwy.

   docker stop core-counter
   

3. Usuwanie kontenera

   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 .

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

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

Następne kroki

• Konteneryzacja aplikacji .NET przy użyciu dotnet publish
• obrazy kontenerów platformy .NET
• konteneryzowanie aplikacji ASP.NET Core
• usług platformy Azure, które obsługują kontenery
• polecenia Dockerfile
• Narzędzia kontenerowe dla Visual Studio