Docker et C# : conteneurisation des applications .NET à partir de zéro

Introduction : pourquoi conteneuriser les applications C# ?

Le développement moderne en C# (.NET) se passe rarement de Docker. La conteneurisation permet d'empaqueter l'application avec toutes ses dépendances, son environnement d'exécution et ses configurations dans une image isolée. Cela résout le problème "ça marche sur ma machine" et simplifie le déploiement sur un serveur, dans le cloud ou sur une infrastructure locale.

Dans cet article, nous allons voir comment créer une image Docker pour une application .NET (ASP.NET Core ou console), optimiser sa taille, utiliser docker-compose pour la lier à une base de données et configurer une CI/CD. Tous les exemples de code sont écrits en C# et prêts à être utilisés.

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

Docker est une plateforme pour exécuter des applications dans des conteneurs. Un conteneur contient tout le nécessaire : le code, l'environnement d'exécution (runtime), les bibliothèques et les configurations. Pour .NET, c'est particulièrement pratique car vous n'avez pas besoin d'installer le SDK .NET sur le serveur — Docker suffit.

1.1. Installation de Docker

Téléchargez et installez Docker Desktop depuis le site officiel. Après l'installation, vérifiez la version :

docker --version

1.2. Structure du projet .NET

Supposons que nous ayons une simple application ASP.NET Core Web API. La structure des dossiers :

MyApp/├── MyApp.csproj├── Program.cs├── Controllers/│   └── WeatherController.cs└── Dockerfile

2. Création d'un Dockerfile pour une application .NET

Le Dockerfile est une instruction pour construire l'image. Pour .NET, il est recommandé d'utiliser une construction multi-étapes (multi-stage build) afin de séparer les phases de construction et d'exécution. Cela réduit la taille finale de l'image.

2.1. Dockerfile de base

Créez un fichier Dockerfile à la racine du projet :

# Étape de constructionFROM mcr.microsoft.com/dotnet/sdk:8.0 AS buildWORKDIR /srcCOPY ["MyApp.csproj", "."]RUN dotnet restoreCOPY . .RUN dotnet publish -c Release -o /app/publish

# Étape d'exécutionFROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtimeWORKDIR /appCOPY --from=build /app/publish .EXPOSE 80ENTRYPOINT ["dotnet", "MyApp.dll"]

Explications :

• FROM ... AS build — nous utilisons le SDK pour la compilation.
• COPY ["MyApp.csproj", "."] — nous copions uniquement le fichier projet pour mettre en cache la restauration.
• RUN dotnet restore — nous restaurons les paquets NuGet.
• RUN dotnet publish — nous construisons la version release.
• FROM ... AS runtime — nous utilisons l'image aspnet minimale.
• EXPOSE 80 — nous ouvrons le port 80.
• ENTRYPOINT — la commande de lancement de l'application.

2.2. Construction et exécution de l'image

Exécutez les commandes dans le terminal depuis le dossier du projet :

docker build -t myapp:latest .docker run -d -p 8080:80 --name myapp_container myapp:latest

Maintenant, l'application est accessible à l'adresse http://localhost:8080.

3. Optimisation des images Docker pour .NET

Les images volumineuses ralentissent le déploiement et consomment des ressources. Voici quelques pratiques pour l'optimisation :

3.1. Utilisez .NET 8 (ou plus récent)

Les nouvelles versions de .NET intègrent la prise en charge de la compilation AOT (Ahead-of-Time), ce qui réduit la taille du runtime. Pour ASP.NET Core, utilisez l'image aspnet:8.0.

3.2. Minimisez les couches

Chaque instruction RUN, COPY crée une couche. Combinez les commandes :

RUN apt-get update && apt-get install -y \    curl \    && rm -rf /var/lib/apt/lists/*

3.3. Utilisez .dockerignore

Créez un fichier .dockerignore à la racine du projet pour exclure les fichiers inutiles :

bin/obj/.vs/*.user.git/README.md

3.4. Exemple de Dockerfile optimisé

FROM mcr.microsoft