Docker et de comment l’utiliser avec C# / .NET dans un projet concret.
Concepts, création d’image, utilisation de Docker avec un projet C#, déploiement local, et outils.
🐳 1. Qu’est-ce que Docker ? (détaillé)
Docker est une plateforme de virtualisation légère qui permet de :
-
Emballer une application + son environnement dans un conteneur.
-
Exécuter ce conteneur partout où Docker est installé (Windows, Linux, macOS, Cloud).
-
Éviter le classique problème : “Ça marche chez moi mais pas sur le serveur”.
⚠️ Contrairement à une machine virtuelle, un conteneur partage le noyau de l'OS, ce qui le rend rapide et léger.
📦 2. Composants Docker
| Élément |
Rôle |
| Image |
Une image Docker est une photographie immuable de l’environnement |
| Conteneur |
Une instance exécutable d’une image |
| Dockerfile |
Fichier qui décrit comment construire une image |
| Docker Hub |
Registre public d’images Docker |
| Volumes |
Permettent de stocker les données en dehors du conteneur |
🧪 3. Exemple : Créer et exécuter une API C# .NET dans Docker
🧰 Prérequis
🧱 Étape 1 : Créer un projet Web API C#
dotnet new webapi -n MonApiDocker
cd MonApiDocker
Vous avez maintenant un projet avec un contrôleur de test.
🐳 Étape 2 : Ajouter un fichier Dockerfile
À la racine du projet, créez un fichier nommé Dockerfile (sans extension) :
# Étape 1 : build
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app
# Étape 2 : runtime
FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "MonApiDocker.dll"]
Ce Dockerfile crée une image multi-étape (build + runtime) pour optimiser la taille finale.
🧪 Étape 3 : Construire l’image Docker
Depuis le dossier du projet (où se trouve le Dockerfile) :
docker build -t monapi-docker .
🚀 Étape 4 : Lancer le conteneur localement
docker run -d -p 5000:80 --name monapi monapi-docker
Cela mappe :
Test dans le navigateur :
http://localhost:5000/weatherforecast
🧪 4. Ajouter SQL Server à votre conteneur (via Docker Compose)
Si vous voulez connecter votre API .NET à une base de données SQL Server dans Docker, vous pouvez utiliser Docker Compose :
🔧 docker-compose.yml
version: '3.4'
services:
api:
build: .
ports:
- "5000:80"
depends_on:
- db
environment:
- ConnectionStrings__Default=Server=db;Database=MaDb;User=sa;Password=Pa$$w0rd;
db:
image: mcr.microsoft.com/mssql/server:2022-latest
environment:
SA_PASSWORD: "Pa$$w0rd"
ACCEPT_EULA: "Y"
ports:
- "1433:1433"
Puis lancez :
docker-compose up --build
🔍 5. Inspecter et déboguer
| Action |
Commande |
| Voir les conteneurs actifs |
docker ps |
| Voir les logs |
docker logs monapi |
| Entrer dans le conteneur |
docker exec -it monapi /bin/bash |
| Supprimer un conteneur |
docker rm monapi |
| Supprimer une image |
docker rmi monapi-docker |
📌 6. Avantages de Docker avec C#/.NET
-
✔️ Déploiement reproductible
-
✔️ Facilité de test et CI/CD
-
✔️ Environnement isolé (lib versions, config…)
-
✔️ Compatible avec Azure, AWS, Kubernetes
🔚 Résumé
| Étapes |
Action |
| 1 |
Créer projet C# .NET |
| 2 |
Ajouter Dockerfile |
| 3 |
Construire avec docker build |
| 4 |
Lancer avec docker run |
| 5 |
(Optionnel) Ajouter une base SQL avec docker-compose |
=========================================================
==========================================================
Un projet complet .NET Web API avec Docker + SQL Server, prêt à être exécuté avec Docker Compose.
🧱 Objectif :
Créer une Web API C# .NET 8, connectée à une base SQL Server, le tout conteneurisé avec Docker et orchestré avec Docker Compose.
📁 Structure du projet final :
/MonApiDocker/
├── Controllers/
│ └── ClientsController.cs
├── Models/
│ └── Client.cs
├── Data/
│ └── AppDbContext.cs
├── Program.cs
├── MonApiDocker.csproj
├── Dockerfile
├── docker-compose.yml
└── appsettings.json
✅ Étape 1 : Créer le projet API
dotnet new webapi -n MonApiDocker
cd MonApiDocker
✏️ Étape 2 : Ajouter les modèles et DbContext
📄 Models/Client.cs
namespace MonApiDocker.Models;
public class Client
{
public int Id { get; set; }
public string Nom { get; set; } = "";
public string Email { get; set; } = "";
}
📄 Data/AppDbContext.cs
using Microsoft.EntityFrameworkCore;
using MonApiDocker.Models;
namespace MonApiDocker.Data;
public class AppDbContext : DbContext
{
public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
public DbSet<Client> Clients => Set<Client>();
}
🎮 Étape 3 : Ajouter un contrôleur simple
📄 Controllers/ClientsController.cs
using Microsoft.AspNetCore.Mvc;
using MonApiDocker.Data;
using MonApiDocker.Models;
namespace MonApiDocker.Controllers;
[ApiController]
[Route("api/[controller]")]
public class ClientsController : ControllerBase
{
private readonly AppDbContext _db;
public ClientsController(AppDbContext db) => _db = db;
[HttpGet]
public IActionResult Get() => Ok(_db.Clients.ToList());
[HttpPost]
public IActionResult Post(Client client)
{
_db.Clients.Add(client);
_db.SaveChanges();
return CreatedAtAction(nameof(Get), new { id = client.Id }, client);
}
}
🧠 Étape 4 : Modifier Program.cs
using Microsoft.EntityFrameworkCore;
using MonApiDocker.Data;
var builder = WebApplication.CreateBuilder(args);
// Ajouter EF Core SQL Server
builder.Services.AddDbContext<AppDbContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
// Créer la base automatiquement (migration auto)
using var scope = app.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
db.Database.Migrate();
app.Run();
🧾 Étape 5 : appsettings.json
{
"ConnectionStrings": {
"Default": "Server=db;Database=ClientsDb;User=sa;Password=Pa$$w0rd;"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
}
}
🐳 Étape 6 : Dockerfile
# Build .NET app
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release -o out
# Runtime image
FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app/out .
ENTRYPOINT ["dotnet", "MonApiDocker.dll"]
🐋 Étape 7 : docker-compose.yml
version: '3.4'
services:
api:
build: .
ports:
- "5000:80"
depends_on:
- db
environment:
- ASPNETCORE_ENVIRONMENT=Development
networks:
- monreseau
db:
image: mcr.microsoft.com/mssql/server:2022-latest
environment:
SA_PASSWORD: "Pa$$w0rd"
ACCEPT_EULA: "Y"
ports:
- "1433:1433"
networks:
- monreseau
networks:
monreseau:
📦 Étape 8 : Ajouter les packages NuGet
Dans le terminal :
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Design
▶️ Étape 9 : Lancer le tout
docker-compose up --build
Accédez à :
📫 http://localhost:5000/api/clients
🧪 Tester avec Postman / Curl
Ajouter un client :
curl -X POST http://localhost:5000/api/clients \
-H "Content-Type: application/json" \
-d '{"nom": "Alice", "email": "alice@example.com"}'
🔚 Résultat :
-
Une API C# .NET dans Docker
-
Une base SQL Server aussi dans Docker
-
L’ensemble connecté automatiquement avec Docker Compose
-
Base de données créée automatiquement via EF Core
.jpg)