Lernprogramm: Containerisieren einer .NET-App

In diesem Lernprogramm erfahren Sie, wie Sie eine .NET-Anwendung mit Docker containern. Container verfügen über viele Features und Vorteile, z. B. eine unveränderliche Infrastruktur, bieten eine tragbare Architektur und ermöglichen skalierbarkeit. Das Image kann verwendet werden, um Container für Ihre lokale Entwicklungsumgebung, private Cloud oder öffentliche Cloud zu erstellen.

In diesem Tutorial:

Sie untersuchen die Aufgaben zum Erstellen und Bereitstellen von Docker-Containern für eine .NET-Anwendung. Die Docker-Plattform verwendet die Docker-Engine, um Pakete schnell als Docker-Images zu erstellen und zu packen. Diese Images werden im Dockerfile-Format geschrieben, um in einem mehrstufigen Container bereitgestellt und ausgeführt zu werden.

Voraussetzungen

Die folgenden Komponenten müssen installiert sein:

• .NET 8+ SDK.
  Wenn .NET installiert ist, verwenden Sie den Befehl dotnet --info, um zu bestimmen, welches SDK Sie verwenden.
• Docker Community Edition.
• Ein temporärer Arbeitsordner für das Dockerfile und eine .NET-Beispiel-App. In diesem Tutorial trägt der Arbeitsordner den Namen docker-working.

Erstellen einer .NET-App

Sie benötigen eine .NET-App, die im Docker-Container läuft. Öffnen Sie Ihr Terminal, erstellen Sie einen Arbeitsordner, falls noch nicht geschehen, und geben Sie den Ordnernamen ein. Führen Sie im Arbeitsordner den folgenden Befehl aus, um ein neues Projekt in einem Unterverzeichnis namens App-zu erstellen:

dotnet new console -o App -n DotNet.Docker

Die Ordnerstruktur sieht ähnlich wie die folgende Verzeichnisstruktur aus:

📁 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

Der Befehl dotnet new erstellt einen neuen Ordner namens App- und generiert eine Konsolenanwendung "Hello World". Ändern Sie jetzt die Verzeichnisse, und navigieren Sie in der Terminalsitzung zum Ordner App. Verwenden Sie den Befehl dotnet run, um die App zu starten. Die Anwendung wird ausgeführt, und Hello World! wird unter dem Befehl ausgegeben:

cd App
dotnet run
Hello World!

Die Standardvorlage erstellt eine App, die eine Ausgabe im Terminal anzeigt und dann sofort beendet wird. Für dieses Tutorial verwenden Sie eine App, die auf unbestimmte Zeit ausgeführt wird. Öffnen Sie die Program.cs Datei in einem Text-Editor.

code .

Die Program.cs sollte wie der folgende C#-Code aussehen:

Console.WriteLine("Hello World!");

Ersetzen Sie die Datei durch den folgenden Code, der Zahlen jede Sekunde zählt:

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

Speichern Sie die Datei, und testen Sie das Programm erneut mit dotnet run. Denken Sie daran, dass diese App unbegrenzt ausgeführt wird. Verwenden Sie den Befehl "Abbrechen" STRG+C, um ihn zu beenden. Betrachten Sie die folgende Beispielausgabe:

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

Wenn Sie dem Programm eine Zahl in der Befehlszeile übergeben, wird die Anzahl auf diesen Wert beschränkt, und das Programm wird beendet. Versuchen Sie es mit dotnet run -- 5, um auf fünf zu zählen.

.NET-App veröffentlichen

Damit die App für die Erstellung von Bildern geeignet ist, muss sie kompiliert werden. Der dotnet publish-Befehl eignet sich am besten dafür, da er die App erstellt und veröffentlicht. Eine ausführliche Referenz finden Sie in der Dokumentation der Befehle dotnet build und dotnet publish.

dotnet publish -c Release

Der Befehl dotnet publish kompiliert Ihre App in den Ordner Veröffentlichen. Der Pfad zum Ordner Veröffentlichen vom Arbeitsordner aus sollte ./App/bin/Release/<TFM>/publish/ sein:

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

Erstellen der Dockerfile

Die Dockerfile-Datei wird vom Befehl docker build zum Erstellen des Containerimage verwendet. Diese Datei ist eine Textdatei mit dem Namen Dockerfile-, die keine Erweiterung hat.

Erstellen Sie eine Datei namens Dockerfile- im Verzeichnis, das die .csproj- enthält, und öffnen Sie sie in einem Text-Editor. In diesem Tutorial wird das ASP.NET Core-Runtimeimage (das das .NET-Runtimeimage enthält) verwendet, das der .NET-Konsolenanwendung entspricht.

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

Die Anweisung ENTRYPOINT setzt dotnet als Host für DotNet.Docker.dllfest. Es ist jedoch möglich, die ENTRYPOINT als die ausführbare App selbst zu definieren, wobei das Betriebssystem als Host der App fungiert.

ENTRYPOINT ["./DotNet.Docker"]

Dies bewirkt, dass die App direkt ohne dotnetausgeführt wird und stattdessen auf dem App-Host und dem zugrunde liegenden Betriebssystem basiert. Weitere Informationen zur Bereitstellung plattformübergreifender Binärdateien finden Sie unter Erstellen einer plattformübergreifenden Binärdatei.

Führen Sie zum Erstellen des Containers vom Terminal den folgenden Befehl aus:

docker build -t counter-image -f Dockerfile .

Docker verarbeitet die einzelnen Zeilen aus dem Dockerfile. . im Befehl docker build legt den Buildkontext des Images fest. Der Schalter -f ist der Pfad zur Dockerfile. Mit diesem Befehl wird das Image erstellt und ein lokales Repository mit dem Namen counter-image angelegt, das auf dieses Bild verweist. Führen Sie nach Abschluss dieses Befehls docker images aus, um eine Liste der installierten Images anzuzeigen:

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

Das Repository counter-image ist der Name des Images. Darüber hinaus sind das Imagetag, die Bildkennung, die Größe und das Erstellungsdatum Teil der Ausgabe. Die letzten Schritte in der Dockerfile sind das Erstellen eines Containers anhand des Images und Ausführen der App, das Kopieren der veröffentlichten App in den Container und das Festlegen des Einstiegspunkts:

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

Der Befehl FROM gibt das zu verwendende Basisbild und das zu verwendende Tag an. Mit dem Befehl WORKDIR wird das aktuelle Verzeichnis im Container in App geändert.

Der Befehl COPY weist Docker an, das angegebene Quellverzeichnis in einen Zielordner zu kopieren. In diesem Beispiel werden die Inhalte in der build Ebene in den Ordner mit dem Namen App/out ausgegeben, sodass es die Quelle ist, aus der kopiert werden soll. Alle im Verzeichnis App/out veröffentlichten Inhalte werden in das aktuelle Arbeitsverzeichnis (App) kopiert.

Der nächste Befehl, ENTRYPOINT, weist Docker an, den Container so zu konfigurieren, dass er als ausführbare Datei ausgeführt wird. Wenn der Container gestartet wird, wird der Befehl ENTRYPOINT ausgeführt. Wenn dieser Befehl fertig ist, stoppt der Container automatisch.

ENV DOTNET_EnableDiagnostics=0

Einen Container erstellen

Nachdem Sie nun über ein Image verfügen, das Ihre App enthält, können Sie einen Container erstellen. Sie können einen Container auf zwei Arten erstellen. Erstellen Sie zunächst einen neuen Container, der beendet wird.

docker create --name core-counter counter-image

Dieser docker create-Befehl erstellt einen Container auf Grundlage des Images counter-image. Die Ausgabe des Befehls docker create zeigt Ihnen die CONTAINER ID (Ihr Bezeichner wird anders sein) des Containers:

d0be06126f7db6dd1cee369d911262a353c9b7fb4829a0c11b4b2eb7b2d429cf

Um eine Liste aller Container zu erhalten, verwenden Sie den docker ps -a-Befehl:

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

Verwalten des Containers

Der Container wurde mit einem bestimmten Namen core-countererstellt. Dieser Name wird zum Verwalten des Containers verwendet. Im folgenden Beispiel wird der Befehl docker start verwendet, um den Container zu starten, und anschließend wird der Befehl docker ps verwendet, um nur ausgeführte Container anzuzeigen:

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

Ebenso stoppt der befehl docker stop den Container. Im folgenden Beispiel wird der Befehl docker stop verwendet, um den Container zu beenden, und dann der Befehl docker ps, um anzuzeigen, dass keine Container ausgeführt werden:

docker stop core-counter
core-counter

docker ps
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Mit einem Container verbinden

Nachdem ein Container ausgeführt wird, können Sie sich mit ihm verbinden, um die Ausgabe anzuzeigen. Verwenden Sie die Befehle docker start und docker attach, um den Container zu starten und einen Blick auf den Ausgabedatenstrom zu werfen. In diesem Beispiel wird die Tastenkombination STRG+C verwendet, um die Trennung vom ausgeführten Container durchzuführen. Diese Tastenkombination beendet den Prozess im Container, sofern nicht anders angegeben, was den Container anhalten würde. Der Parameter --sig-proxy=false stellt sicher, dass STRG+C den Prozess im Container nicht anhält.

Nachdem Sie den Container abgetrennt haben, fügen Sie ihn erneut an, um sicherzustellen, dass er noch läuft und zählt.

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

Container löschen

In diesem Artikel möchten Sie nicht, dass Container vorhanden sind, die nichts bewirken. Löschen Sie den zuvor erstellten Container. Wenn der Container ausgeführt wird, beenden Sie ihn.

docker stop core-counter

Im folgenden Beispiel werden alle Container aufgelistet. Anschließend wird der Befehl docker rm verwendet, um den Container zu löschen, und danach überprüft das System ein zweites Mal, ob es laufende Container gibt.

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

Einzelausführung

Docker stellt den docker run Befehl zum Erstellen und Ausführen des Containers als einzelner Befehl bereit. Dieser Befehl beseitigt die Notwendigkeit, docker create auszuführen und dann docker start. Sie können diesen Befehl auch so festlegen, dass der Container automatisch gelöscht wird, wenn der Container beendet wird. Verwenden Sie beispielsweise docker run -it --rm, um zwei Dinge zu erledigen: Erstens das aktuelle Terminal automatisch zu verwenden, um sich mit dem Container zu verbinden, und danach den Container zu entfernen, wenn er fertig ist.

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

Der Container übergibt auch Parameter an die Ausführung der .NET-App, Um die .NET-App dazu zu bringen, nur bis drei zu zählen, geben Sie 3 ein.

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

Mit docker run -itbeendet der Befehl Strg+C den Prozess, der im Container ausgeführt wird, dadurch wird der Container gestoppt. Da der parameter --rm bereitgestellt wurde, wird der Container automatisch gelöscht, wenn der Prozess beendet wird. Stellen Sie sicher, dass sie nicht vorhanden ist:

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

Ändern des EINSTIEGSPUNKTS

Mit dem Befehl docker run können Sie auch den befehl ENTRYPOINT aus dem Dockerfile- ändern und etwas anderes ausführen, aber nur für diesen Container. Verwenden Sie beispielsweise den folgenden Befehl, um bash oder cmd.exeauszuführen. Bearbeiten Sie den Befehl nach Bedarf.

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

Wichtige Befehle

Docker verfügt über viele verschiedene Befehle zum Erstellen, Verwalten und Interagieren mit Containern und Images. Diese Docker-Befehle sind für die Verwaltung Ihrer Container unerlässlich:

• docker build
• docker run
• docker ps
• docker stop
• docker rm
• docker rmi
• docker image

Bereinigen von Ressourcen

In diesem Tutorial haben Sie Container und Images erstellt. Wenn Sie möchten, löschen Sie diese Ressourcen. Führen Sie die folgenden Befehle für diese Aktionen aus:

1. Alle Container auflisten

   docker ps -a
   

2. Zum Anhalten aller ausgeführten Container nach Namen

   docker stop core-counter
   

3. Löschen des Containers

   docker rm core-counter
   

Löschen Sie als Nächstes alle Bilder, die Sie nicht mehr auf Ihrem Computer benötigen. Löschen Sie das von Ihrem Dockerfile- erstellte Image, und löschen Sie dann das .NET-Image, auf dem die Dockerfile- basiert. Sie können die IMAGE ID oder die mit REPOSITORY:TAG formatierte Zeichenfolge verwenden.

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

Verwenden Sie den Befehl docker images, um eine Liste der installierten Images anzuzeigen.

Nächste Schritte

• Containerisieren einer .NET-App mit dem Befehl „dotnet publish“
• .NET-Containerimages
• Containerisieren einer ASP.NET Core-Anwendung
• Azure-Dienste, die Container unterstützen
• Dockerfile-Befehle
• Containertools für Visual Studio