jeudi 1 juin 2023

Exemple Docker

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 :

  • Le port interne 80 du conteneur

  • Au port 5000 de votre machine locale

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


Posted by at
Labels:

Aucun commentaire:

Enregistrer un commentaire

Exemple Docker Lượt xem:
Inscription à : Publier les commentaires (Atom)