Deployer .NET avec Docker

Pourquoi Deployer .NET avec Docker ?

Deploiement .NET avec Docker est une pratique essentielle pour les développeurs modernes. En effet, Docker permet de créer des environnements d'exécution standardisés et portables, facilitant ainsi le partage et la mise en production du code. Un cas concret est celui d'un développeur qui travaille sur une API de blog. Chaque fois qu'elle est déployée sur un nouveau serveur, il peut y avoir des différences dans les bibliothèques .NET installées ou la configuration du système d'exploitation. Avec Docker, ces variations sont éliminées, assurant que l'API fonctionnera toujours de la même manière.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Connaissance avancée de .NET Core ou .NET 6+
• Docker et Docker Compose installés sur votre machine
  • Docker : https://docs.docker.com/get-docker/
  • Docker Compose : https://docs.docker.com/compose/install/
• Visual Studio Code ou tout autre éditeur de texte pour le développement

Concepts fondamentaux

Concept 1 : Images et Conteneurs

Image : C'est une image Docker qui contient toutes les instructions nécessaires pour créer un conteneur. Elle est souvent basée sur une image officielle .NET.

Conteneur : C'est une instance exécutable de l'image Docker, avec des ressources spécifiques allouées et accessible via un réseau local.

Exemple de code pour créer une image Docker

## Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "YourApp.dll"]

Concept 2 : Docker Compose

Docker Compose est un utilitaire pour définir et exécuter des applications multi-conteneurs en utilisant des fichiers YAML.

Exemple de fichier docker-compose.yml

## docker-compose.yml
version: '3.8'
services:
  web:
    image: yourappimage
    ports:
      - "5000:80"

Concept 3 : Volumes et Bind Mounts

Volumes permettent de persister des données entre les conteneurs et le système d'exploitation hôte.

Bind Mounts permettent de partager des fichiers ou des répertoires entre le système d'exploitation hôte et un conteneur.

Exemple de volume dans docker-compose.yml

## docker-compose.yml
version: '3.8'
services:
  web:
    image: yourappimage
    volumes:
      - ./logs:/app/logs

Mise en pratique : Projet fil rouge

Dans cette section, nous allons créer un simple gestionnaire de tâches basé sur .NET Core et Docker.

Étape 1 : Créer le projet .NET Core

dotnet new console -n TaskManager
cd TaskManager

Étape 2 : Ajouter des fonctionnalités au programme

Ajoutez la classe TaskManager suivante :

// Program.cs
using System;
using System.Collections.Generic;

namespace TaskManager
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> tasks = new List<string>();
            string input;

            while (true)
            {
                Console.WriteLine("1. Ajouter une tâche");
                Console.WriteLine("2. Afficher les tâches");
                Console.WriteLine("3. Quitter");
                Console.Write("Choisissez une option : ");
                input = Console.ReadLine();

                switch (input)
                {
                    case "1":
                        Console.Write("Entrez le nom de la tâche : ");
                        string taskName = Console.ReadLine();
                        tasks.Add(taskName);
                        break;
                    case "2":
                        Console.WriteLine("Liste des tâches :");
                        foreach (var task in tasks)
                        {
                            Console.WriteLine("- " + task);
                        }
                        break;
                    case "3":
                        return;
                    default:
                        Console.WriteLine("Option invalide. Veuillez choisir une option valide.");
                        break;
                }
            }
        }
    }
}

Étape 3 : Créer le Dockerfile

## Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "TaskManager.dll"]

Étape 4 : Créer le fichier docker-compose.yml

## docker-compose.yml
version: '3.8'
services:
  web:
    build: .
    ports:
      - "5000:80"

Étape 5 : Construire et exécuter l'application Docker

docker-compose up --build

Erreurs fréquentes et debugging

Erreur 1 : L'image Docker ne se construit pas correctement

Code incorrect

## ❌ Mauvais
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "YourApp.dll"]

Code correct

## ✅ Correct
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "TaskManager.dll"]

Erreur 2 : L'application ne démarre pas

Code incorrect

## ❌ Mauvais
docker-compose up

Code correct

## ✅ Correct
docker-compose up --build

Pour aller plus loin

1. Utiliser des secrets et des variables d'environnement : Docker Secrets Docker Environment Variables

2. Optimiser les images Docker avec multi-stage builds : Multi-stage Builds

3. Utiliser des registries privés pour stocker vos images : Docker Hub Azure Container Registry

Défi pratique : Créez un petit service web qui expose une API RESTful pour gérer des utilisateurs. Utilisez Docker et Docker Compose pour déployer le service en production.

N'oubliez pas de suivre les meilleures pratiques de sécurité et de gestion des ressources lors de la création d'applications à grande échelle avec Docker.