Docker et C# : conteneurisation d'applications de A à Z

Docker et C# : guide complet pour la conteneurisation d'applications .NET

La conteneurisation est devenue le standard de facto pour le déploiement d'applications modernes. Si vous développez en C# (.NET), Docker vous permet d'empaqueter votre application avec toutes ses dépendances dans un conteneur léger et isolé. Dans cet article, nous allons parcourir le chemin allant de la création d'un simple Dockerfile à la publication et à l'exécution d'une image prête. Vous apprendrez à conteneuriser une application en C#, à optimiser la taille de l'image et à utiliser les meilleures pratiques.

1. Bases de Docker pour le développeur .NET

Docker est une plateforme de développement, de livraison et d'exécution d'applications dans des conteneurs. Un conteneur est une unité logicielle standardisée qui inclut le code et toutes ses dépendances. Contrairement aux machines virtuelles, les conteneurs utilisent le noyau commun du système d'exploitation, ce qui les rend plus rapides et plus légers.

Pour C# (.NET), Docker est particulièrement utile car il résout le problème "ça marche chez moi" — vous garantissez que l'application se comportera de la même manière sur la machine du développeur, le serveur de test et en production. Les composants principaux :

• Docker Engine — l'environnement d'exécution des conteneurs
• Dockerfile — fichier texte avec les instructions de construction de l'image
• Image — modèle immuable pour créer des conteneurs
• Conteneur — instance en cours d'exécution de l'image

Installez Docker Desktop pour Windows/Mac ou Docker Engine pour Linux. Après l'installation, vérifiez le fonctionnement avec la commande :

docker --version

2. Création d'un Dockerfile pour une application C# (.NET)

Commençons par une simple application ASP.NET Core Web API. Créez un nouveau projet :

dotnet new webapi -n MyDockerAppcd MyDockerApp

Créez maintenant un fichier Dockerfile (sans extension) à la racine du projet. Voici une version de base avec une construction multi-étapes (multi-stage build) :

# Étape 1 : construction de l'applicationFROM mcr.microsoft.com/dotnet/sdk:8.0 AS buildWORKDIR /src

# Copie du fichier csproj et restauration des dépendancesCOPY ["MyDockerApp.csproj", "."]RUN dotnet restore

# Copie du reste du code et compilation du projetCOPY . .RUN dotnet publish -c Release -o /app/publish

# Étape 2 : création d'une image minimale pour l'exécutionFROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtimeWORKDIR /appEXPOSE 80EXPOSE 443

# Copie de l'application compilée depuis la première étapeCOPY --from=build /app/publish .

# Point d'entréeENTRYPOINT ["dotnet", "MyDockerApp.dll"]

Explication des instructions clés :

• FROM — définit l'image de base (SDK pour la construction, ASP.NET pour l'exécution)
• WORKDIR — définit le répertoire de travail
• COPY — copie les fichiers du contexte de construction vers l'image
• RUN dotnet restore — restaure les paquets NuGet
• RUN dotnet publish — compile et publie l'application
• EXPOSE — indique les ports que le conteneur écoutera
• ENTRYPOINT — commande exécutée au démarrage du conteneur

La construction multi-étapes est cruciale pour C# : l'image finale contient uniquement le runtime et votre application, sans le SDK ni les sources. Cela réduit la taille de l'image d'environ 1,5 Go à environ 200 Mo.

3. Construction et exécution du conteneur

Construisez l'image Docker :

docker build -t my-dotnet-app:latest .

Le drapeau -t définit le tag (nom:version). Le point à la fin indique le répertoire courant comme contexte de construction.

Exécutez le conteneur :

docker run -d -p 8080:80 --name my-app my-dotnet-app:latest

Paramètres :

• -d — exécution en arrière-plan (detached)
• -p 8080:80 — redirection de port : port hôte 8080