Tutoriel : Conteneuriser une application .NET
Dans ce tutoriel, vous allez apprendre à conteneuriser une application .NET avec Docker. Les conteneurs présentent de nombreuses fonctionnalités et avantages, tels que l’utilisation d’une infrastructure immuable, la fourniture d’une architecture portable et l’activation de l’extensibilité. L’image peut être utilisée pour créer des conteneurs pour votre environnement de développement local, votre cloud privé ou votre cloud public.
Dans ce tutoriel, vous allez :
- Créer et publier une application .NET simple
- Créer et configurer un fichier Dockerfile pour .NET
- Générer une image Docker
- Créer et exécuter un conteneur Docker
Vous explorez la génération et le déploiement de tâches de conteneur Docker pour une application .NET. La plateforme Docker utilise le moteur Docker pour générer et empaqueter rapidement des applications en tant qu’images Docker . Ces images sont écrites au format Dockerfile à déployer et à exécuter dans un conteneur en couches.
Conseil
Si vous souhaitez publier votre application .NET en tant que conteneur sans avoir besoin de Docker ou Podman, consultez Containerize une application .NET avec dotnet publish.
Remarque
Ce didacticiel n’est pas pour les applications ASP.NET Core. Si vous utilisez ASP.NET Core, consultez le didacticiel sur la conteneurisation d'une application ASP.NET Core.
Conditions préalables
Installez les conditions préalables suivantes :
- SDK .NET 8+
Si vous avez installé .NET, utilisez la commandedotnet --infopour déterminer le Kit de développement logiciel (SDK) que vous utilisez. - Docker Community Edition.
- Un dossier de travail temporaire pour Dockerfile et un exemple d’application .NET. Dans ce tutoriel, le nom docker-working est utilisé comme dossier de travail.
Créer une application .NET
Vous avez besoin d’une application .NET exécutée par le conteneur Docker. Ouvrez votre terminal, créez un dossier de travail si vous ne l’avez pas déjà fait et entrez-le. Dans le dossier de travail, exécutez la commande suivante pour créer un projet dans un sous-répertoire nommé App:
dotnet new console -o App -n DotNet.Docker
Votre arborescence de dossiers ressemble à la structure de répertoires suivante :
📁 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
La commande dotnet new crée un dossier nommé App et génère une application console « Hello World ». À présent, vous modifiez les répertoires et accédez au dossier de l’application dotnet run pour démarrer l’application. L’application s’exécute et imprime Hello World! sous la commande :
cd App
dotnet run
Hello World!
Le modèle par défaut crée une application qui s’imprime sur le terminal, puis se termine immédiatement. Pour ce tutoriel, vous utilisez une application qui se boucle indéfiniment. Ouvrez le fichier Program.cs dans un éditeur de texte.
Conseil
Si vous utilisez Visual Studio Code, à partir de la session terminal précédente, tapez la commande suivante :
code .
Cette commande ouvre le dossier App qui contient le projet dans Visual Studio Code.
Les Program.cs doivent ressembler au code C# suivant :
Console.WriteLine("Hello World!");
Remplacez le fichier par le code suivant qui compte les nombres toutes les secondes :
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));
}
Enregistrez le fichier et testez à nouveau le programme avec dotnet run. N’oubliez pas que cette application s’exécute indéfiniment. Utilisez la commande Cancel Ctrl+C pour l’arrêter. Considérez l’exemple de sortie suivant :
dotnet run
Counter: 1
Counter: 2
Counter: 3
Counter: 4
^C
Si vous passez un nombre sur la ligne de commande à l'application, elle limite le comptage à cette valeur, puis quitte. Essayez-le avec dotnet run -- 5 pour compter jusqu'à cinq.
Important
Tous les paramètres après -- ne sont pas passés à la commande dotnet run et sont passés à votre application.
Publier une application .NET
Pour que l’application soit adaptée à une création d’image, elle doit être compilée. La commande dotnet publish est la plus appropriée pour cela, car elle génère et publie l’application. Pour obtenir une référence détaillée, consultez la documentation sur les commandes dotnet build et dotnet publish.
dotnet publish -c Release
Conseil
Si vous souhaitez publier votre application .NET en tant que conteneur sans avoir besoin de Docker, consultez Containerize une application .NET avec dotnet publish.
La commande dotnet publish compile votre application dans le dossier publish. Le chemin d’accès au dossier publish à partir du dossier de travail doit être ./App/bin/Release/<TFM>/publish/ :
À partir du dossier de l’application
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
Créer le fichier Dockerfile
Le fichier dockerfile est utilisé par la commande docker build pour créer une image conteneur. Ce fichier est un fichier texte nommé fichier Dockerfile qui n’a pas d’extension.
Créez un fichier nommé
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"]
Remarque
L’image runtime ASP.NET Core est utilisée intentionnellement ici, bien que l’image mcr.microsoft.com/dotnet/runtime:9.0 puisse être utilisée à la place.
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"]
Remarque
L’image runtime ASP.NET Core est utilisée intentionnellement ici, bien que l’image mcr.microsoft.com/dotnet/runtime:8.0 puisse être utilisée à la place.
Important
L’inclusion d’un algorithme de hachage sécurisé (SHA) après la balise d’image dans un Dockerfile est une bonne pratique. Cela garantit que l’image n’est pas falsifiée et que l’image est identique à celle que vous attendez. Sha est un identificateur unique pour l’image. Pour plus d’informations, consultez Docker Docs : extraire une image par synthèse.
Conseil
Cette Dockerfile utilise des constructions multi-étapes, qui optimisent la taille finale de l’image en structurant les constructions et en laissant uniquement les éléments requis. Pour plus d’informations, consultez Docker Docs : constructions multi-étapes.
Le mot clé FROM nécessite un nom complet d’image de conteneur Docker. Microsoft Container Registry (MCR, mcr.microsoft.com) est un syndicat de Docker Hub, qui héberge des conteneurs accessibles publiquement. Le segment dotnet est le référentiel de conteneurs, tandis que le segment sdk ou aspnet est le nom de l’image conteneur. L’image est étiquetée avec 9.0, qui est utilisée pour le contrôle de version. Par conséquent, mcr.microsoft.com/dotnet/aspnet:9.0 est le runtime .NET 9.0. Vérifiez que vous extrayez la version du runtime qui correspond au runtime ciblé par votre Kit de développement logiciel (SDK). Par exemple, l’application créée dans la section précédente a utilisé le Kit de développement logiciel (SDK) .NET 9.0 et l’image de base référencée dans le Dockerfile est étiquetée avec 9.0.
Important
Lorsque vous utilisez des images conteneur windows, vous devez spécifier la balise d’image au-delà de 9.0, par exemple, mcr.microsoft.com/dotnet/aspnet:9.0-nanoserver-1809 au lieu de mcr.microsoft.com/dotnet/aspnet:9.0. Sélectionnez un nom d’image selon que vous utilisez Nano Server ou Windows Server Core et quelle version de ce système d’exploitation. Vous pouvez trouver la liste complète de toutes les balises prises en charge sur la page Docker Hub de .NET .
Enregistrez le fichier Dockerfile. La structure de répertoires du dossier de travail doit ressembler à ce qui suit. Certains des fichiers et dossiers de niveau plus approfondi sont omis pour économiser de l’espace dans l’article :
📁 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
└──...
Le mot clé FROM nécessite un nom pleinement qualifié d'image de conteneur Docker. Microsoft Container Registry (MCR, mcr.microsoft.com) est un syndicat de Docker Hub, qui héberge des conteneurs accessibles publiquement. Le segment dotnet est le référentiel de conteneurs, tandis que le segment sdk ou aspnet est le nom de l’image conteneur. L’image est étiquetée avec 8.0, qui est utilisée pour le contrôle de version. Par conséquent, mcr.microsoft.com/dotnet/aspnet:8.0 est le runtime .NET 8.0. Vérifiez que vous extrayez la version du runtime qui correspond au runtime ciblé par votre Kit de développement logiciel (SDK). Par exemple, l’application créée dans la section précédente a utilisé le Kit de développement logiciel (SDK) .NET 8.0 et l’image de base référencée dans le Dockerfile est marquée avec 8.0.
Important
Lorsque vous utilisez des images conteneur windows, vous devez spécifier la balise d’image au-delà de 8.0, par exemple, mcr.microsoft.com/dotnet/aspnet:8.0-nanoserver-1809 au lieu de mcr.microsoft.com/dotnet/aspnet:8.0. Sélectionnez un nom d’image selon que vous utilisez Nano Server ou Windows Server Core et quelle version de ce système d’exploitation. YVous trouverez la liste complète de toutes les balises prises en charge sur la page Docker Hub de .NET.
Enregistrez le fichier Dockerfile. La structure de répertoires du dossier de travail doit ressembler à ce qui suit. Certains des fichiers et dossiers de niveau plus approfondi sont omis pour économiser de l’espace dans l’article :
📁 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
└──...
L’instruction ENTRYPOINT définit dotnet en tant qu’hôte pour le DotNet.Docker.dll. Toutefois, il est possible de définir le ENTRYPOINT comme exécutable d’application lui-même, en s’appuyant sur le système d’exploitation en tant qu’hôte d’application :
ENTRYPOINT ["./DotNet.Docker"]
Cela entraîne l’exécution directe de l’application, sans dotnet, et s’appuie plutôt sur l’hôte de l’application et le système d’exploitation sous-jacent. Pour plus d’informations sur le déploiement de fichiers binaires multiplateformes, consultez Produire un binaire multiplateforme.
Pour générer le conteneur, à partir de votre terminal, exécutez la commande suivante :
docker build -t counter-image -f Dockerfile .
Docker traite chaque ligne du fichier Dockerfile . La . dans la commande docker build définit le contexte de génération de l’image. Le commutateur -f est le chemin d'accès au Dockerfile . Cette commande génère l’image et crée un référentiel local nommé contre-image qui pointe vers cette image. Une fois cette commande terminée, exécutez docker images pour afficher la liste des images installées :
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
Le dépôt counter-image est le nom de l’image. En outre, la balise d’image, l’identificateur d’image, la taille et la date de création font toutes partie de la sortie. Les dernières étapes de l'Dockerfile sont de créer un conteneur à partir de l’image et d’exécuter l’application, de copier l’application publiée dans le conteneur et de définir le point d’entrée :
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"]
La commande FROM spécifie l’image de base et la balise à utiliser. La commande WORKDIR modifie le répertoire actif à l’intérieur du conteneur en App.
La commande COPY indique à Docker de copier le répertoire source spécifié dans un dossier de destination. Dans cet exemple, les contenus de publish dans la couche build ont générés dans le dossier nommé App/out. C’est pourquoi il s’agit de la source à partir de laquelle copier. Tous les contenus publiés dans le répertoire App/out sont copiés dans le répertoire de travail actuel (App).
La commande suivante, ENTRYPOINT, indique à Docker de configurer le conteneur pour qu’il s’exécute en tant qu’exécutable. Au démarrage du conteneur, la commande ENTRYPOINT s’exécute. Lorsque cette commande se termine, le conteneur s’arrête automatiquement.
Conseil
Avant .NET 8, les conteneurs configurés pour s’exécuter en lecture seule peuvent échouer avec Failed to create CoreCLR, HRESULT: 0x8007000E. Pour résoudre ce problème, spécifiez une variable d’environnement DOTNET_EnableDiagnostics comme 0 (juste avant l’étape de ENTRYPOINT) :
ENV DOTNET_EnableDiagnostics=0
Pour plus d’informations sur les différentes variables d’environnement .NET, consultez variables d’environnement .NET.
Remarque
.NET 6 standardise le préfixe DOTNET_ au lieu de COMPlus_ pour les variables d’environnement qui configurent le comportement d’exécution de .NET. Toutefois, le préfixe COMPlus_ continuera de fonctionner. Si vous utilisez une version précédente du runtime .NET, vous devez toujours utiliser le préfixe COMPlus_ pour les variables d’environnement.
Créer un conteneur
Maintenant que vous disposez d’une image qui contient votre application, vous pouvez créer un conteneur. Vous pouvez créer un conteneur de deux façons. Tout d’abord, créez un conteneur arrêté.
docker create --name core-counter counter-image
Cette commande docker create crée un conteneur basé sur l’image de contre-image . La sortie de la commande docker create affiche l’ID conteneur du conteneur (votre identificateur sera différent) :
d0be06126f7db6dd1cee369d911262a353c9b7fb4829a0c11b4b2eb7b2d429cf
Pour afficher une liste de tous les conteneurs, utilisez la commande 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
Gérer le conteneur
Le conteneur a été créé avec un nom spécifique core-counter. Ce nom est utilisé pour gérer le conteneur. L’exemple suivant utilise la commande docker start pour démarrer le conteneur, puis utilise la commande docker ps pour afficher uniquement les conteneurs en cours d’exécution :
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
De même, la commande docker stop arrête le conteneur. L’exemple suivant utilise la commande docker stop pour arrêter le conteneur, puis utilise la commande docker ps pour montrer qu’aucun conteneur n’est en cours d’exécution :
docker stop core-counter
core-counter
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
Se connecter à un conteneur
Une fois qu’un conteneur est en cours d’exécution, vous pouvez vous y connecter pour afficher la sortie. Utilisez les commandes docker start et docker attach pour démarrer le conteneur et examiner le flux de sortie. Dans cet exemple, la séquence de touches Ctrl+C est utilisée pour se détacher du conteneur en cours d’exécution. Cette séquence de touches met fin au processus dans le conteneur, sauf indication contraire, qui arrêterait le conteneur. Le paramètre --sig-proxy=false garantit que Ctrl+C n’arrête pas le processus dans le conteneur.
Après vous être déconnecté du conteneur, reconnectez-vous pour vérifier qu’il est toujours en cours d’exécution et de comptage.
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
Supprimer un conteneur
Pour cet article, vous ne souhaitez pas avoir de conteneurs inutiles. Supprimez le conteneur que vous avez créé précédemment. Si le conteneur fonctionne, arrêtez-le.
docker stop core-counter
L’exemple suivant répertorie tous les conteneurs. Il utilise ensuite la commande docker rm pour supprimer le conteneur, puis vérifie une deuxième fois pour tous les conteneurs en cours d’exécution.
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
Exécution unique
Docker fournit la commande docker run pour créer et exécuter le conteneur en tant que commande unique. Cette commande élimine la nécessité d’exécuter docker create, puis de docker start. Vous pouvez également définir cette commande pour supprimer automatiquement le conteneur lorsque le conteneur s’arrête. Par exemple, utilisez docker run -it --rm pour effectuer deux opérations, tout d’abord, utilisez automatiquement le terminal actuel pour vous connecter au conteneur, puis lorsque le conteneur se termine, supprimez-le :
docker run -it --rm counter-image
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
^C
Le conteneur transmet également des paramètres à l’exécution de l’application .NET. Pour indiquer à l’application .NET de compter uniquement sur trois transmis dans 3.
docker run -it --rm counter-image 3
Counter: 1
Counter: 2
Counter: 3
Avec docker run -it, la commande Ctrl+C arrête le processus en cours d’exécution dans le conteneur, qui, à son tour, arrête le conteneur. Étant donné que le paramètre --rm a été fourni, le conteneur est automatiquement supprimé lorsque le processus est arrêté. Vérifiez qu’il n’existe pas :
docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
Modifier la commande ENTRYPOINT
La commande docker run vous permet également de modifier la commande ENTRYPOINT à partir du fichier Dockerfile et d’exécuter autre chose, mais uniquement pour ce conteneur. Par exemple, utilisez la commande suivante pour exécuter bash ou cmd.exe. Modifiez la commande si nécessaire.
Dans cet exemple, ENTRYPOINT est remplacé par cmd.exe. Ctrl+C est enfoncée pour mettre fin au processus et arrêter le conteneur.
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
Remarque
Cet exemple fonctionne uniquement sur les conteneurs Windows. Les conteneurs Linux n’ont pas cmd.exe.
Commandes essentielles
Docker possède de nombreuses commandes différentes qui créent, gèrent et interagissent avec des conteneurs et des images. Ces commandes Docker sont essentielles à la gestion de vos conteneurs :
Nettoyer les ressources
Au cours de ce didacticiel, vous avez créé des conteneurs et des images. Si vous le souhaitez, supprimez ces ressources. Utilisez les commandes suivantes pour
Répertorier tous les conteneurs
docker ps -aArrêtez les conteneurs qui s’exécutent par leur nom.
docker stop core-counterSupprimer le conteneur
docker rm core-counter
Ensuite, supprimez les images que vous ne souhaitez plus sur votre ordinateur. Supprimez l’image créée par votre Dockerfile, puis supprimez l’image .NET sur laquelle le Dockerfile a été basé. Vous pouvez utiliser l'ID d'image ou la chaîne formatée 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
Utilisez la commande docker images pour afficher la liste des images installées.
Conseil
Les fichiers image peuvent être volumineux. En règle générale, vous supprimez les conteneurs temporaires que vous avez créés lors du test et du développement de votre application. Vous conservez généralement les images de base avec le runtime installé si vous prévoyez de générer d’autres images en fonction de ce runtime.
