Prompt de Containerisation Docker pour ASP.NET Core

Demande de Containerisation

Containerisez le projet ASP.NET Core (.NET) spécifié dans les paramètres ci-dessous, en vous concentrant exclusivement sur les modifications requises pour que l'application s'exécute dans un conteneur Docker Linux. La containerisation doit tenir compte de tous les paramètres spécifiés ici.

Respectez les meilleures pratiques pour containeriser les applications .NET Core, en veillant à ce que le conteneur soit optimisé en termes de performance, de sécurité et de maintenabilité.

Paramètres de Containerisation

Cette section du prompt contient les paramètres et configurations spécifiques requis pour containeriser l'application ASP.NET Core. Avant d'exécuter ce prompt, assurez-vous que les paramètres sont remplis avec les informations nécessaires. Notez que dans de nombreux cas, seuls les premiers paramètres sont requis. Les paramètres ultérieurs peuvent être laissés aux valeurs par défaut s'ils ne s'appliquent pas au projet à containeriser.

Tout paramètre non spécifié sera défini avec des valeurs par défaut. Les valeurs par défaut sont fournies entre [crochets].

Informations de Base du Projet

Projet à containeriser :
- [Nom du projet (fournir le chemin du fichier .csproj)]
Version .NET à utiliser :
- [8.0 ou 9.0 (Par défaut 8.0)]
Distribution Linux à utiliser :
- [debian, alpine, ubuntu, chiseled, ou Azure Linux (mariner) (Par défaut debian)]
Image de base personnalisée pour l'étape de build de l'image Docker (« None » pour utiliser l'image de base standard Microsoft) :
- [Spécifier l'image de base à utiliser pour l'étape de build (Par défaut None)]
Image de base personnalisée pour l'étape d'exécution de l'image Docker (« None » pour utiliser l'image de base standard Microsoft) :
- [Spécifier l'image de base à utiliser pour l'étape d'exécution (Par défaut None)]

Configuration du Conteneur

Ports à exposer dans l'image du conteneur :
- Port HTTP principal : [par ex., 8080]
- Ports supplémentaires : [Lister les ports supplémentaires, ou « None »]
Compte utilisateur sous lequel le conteneur doit s'exécuter :
- [Compte utilisateur, ou par défaut « $APP_UID »]
Configuration de l'URL de l'application :
- [Spécifier ASPNETCORE_URLS, ou par défaut « http://+:8080 »]

Configuration de Build

Étapes de build personnalisées à effectuer avant la création de l'image Docker :
- [Lister les étapes de build spécifiques, ou « None »]
Étapes de build personnalisées à effectuer après la création de l'image Docker :
- [Lister les étapes de build spécifiques, ou « None »]
Sources de packages NuGet à configurer :
- [Lister les flux NuGet privés avec détails d'authentification, ou « None »]

Dépendances

Packages système à installer dans l'image du conteneur :
- [Noms de packages pour la distribution Linux choisie, ou « None »]
Bibliothèques natives à copier dans l'image du conteneur :
- [Noms de bibliothèques et chemins, ou « None »]
Outils .NET supplémentaires à installer :
- [Noms et versions des outils, ou « None »]

Configuration du Système

Variables d'environnement à définir dans l'image du conteneur :
- [Noms et valeurs des variables, ou « Utiliser les valeurs par défaut »]

Système de Fichiers

Fichiers/répertoires à copier dans l'image du conteneur :
- [Chemins relatifs à la racine du projet, ou « None »]
- Emplacement cible dans le conteneur : [Chemins du conteneur, ou « Non applicable »]
Fichiers/répertoires à exclure de la containerisation :
- [Chemins à exclure, ou « None »]
Points de montage de volume à configurer :
- [Chemins de volume pour les données persistantes, ou « None »]

Configuration de .dockerignore

Motifs à inclure dans le fichier .dockerignore (le fichier .dockerignore aura déjà des valeurs par défaut communes ; ce sont des motifs supplémentaires) :
- Motifs supplémentaires : [Lister les motifs supplémentaires, ou « None »]

Configuration du Health Check

Endpoint du health check :
- [Chemin de l'URL du health check, ou « None »]
Intervalle et délai d'expiration du health check :
- [Valeurs d'intervalle et de délai d'expiration, ou « Utiliser les valeurs par défaut »]

Instructions Supplémentaires

Autres instructions à suivre pour containeriser le projet :
- [Exigences spécifiques, ou « None »]
Problèmes connus à résoudre :
- [Décrire les problèmes connus, ou « None »]

Portée

✅ Modification de la configuration de l'application pour assurer que les paramètres de l'application et les chaînes de connexion peuvent être lus à partir de variables d'environnement
✅ Création et configuration du Dockerfile pour une application ASP.NET Core
✅ Spécification de plusieurs étapes dans le Dockerfile pour compiler/publier l'application et copier la sortie vers l'image finale
✅ Configuration de la compatibilité de la plateforme du conteneur Linux (Alpine, Ubuntu, Chiseled, ou Azure Linux (Mariner))
✅ Gestion appropriée des dépendances (packages système, bibliothèques natives, outils supplémentaires)
❌ Aucune configuration d'infrastructure (supposée être gérée séparément)
❌ Aucune modification de code au-delà de celles requises pour la containerisation

Processus d'Exécution

Examinez les paramètres de containerisation ci-dessus pour comprendre les exigences de containerisation
Créez un fichier progress.md pour suivre les modifications avec des cases à cocher
Déterminez la version .NET à partir du fichier .csproj du projet en vérifiant l'élément TargetFramework
Sélectionnez l'image de conteneur Linux appropriée en fonction de :
- La version .NET détectée à partir du projet
- La distribution Linux spécifiée dans les paramètres de containerisation (Alpine, Ubuntu, Chiseled, ou Azure Linux (Mariner))
- Si l'utilisateur ne demande pas d'images de base spécifiques dans les paramètres de containerisation, alors les images de base DOIVENT être des images mcr.microsoft.com/dotnet valides avec une balise telle que montrée dans l'exemple Dockerfile ci-dessous, ou dans la documentation
- Images .NET officielles de Microsoft pour les étapes de build et d'exécution :
  - Balises d'images SDK (pour l'étape de build) : https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md
  - Balises d'images runtime ASP.NET Core : https://github.com/dotnet/dotnet-docker/blob/main/README.aspnet.md
  - Balises d'images runtime .NET : https://github.com/dotnet/dotnet-docker/blob/main/README.runtime.md
Créez un Dockerfile à la racine du répertoire du projet pour containeriser l'application
- Le Dockerfile doit utiliser plusieurs étapes :
  - Étape de build : Utilisez une image .NET SDK pour compiler l'application
    - Copiez d'abord le fichier csproj
    - Copiez NuGet.config s'il existe et configurez les flux privés
    - Restaurez les packages NuGet
    - Puis, copiez le reste du code source et compilez et publiez l'application dans /app/publish
  - Étape finale : Utilisez l'image runtime .NET sélectionnée pour exécuter l'application
    - Définissez le répertoire de travail sur /app
    - Définissez l'utilisateur comme dirigé (par défaut, vers un utilisateur non-root comme $APP_UID)
      - Sauf indication contraire dans les paramètres de containerisation, un nouvel utilisateur n'a pas besoin d'être créé. Utilisez la variable $APP_UID pour spécifier le compte utilisateur.
    - Copiez la sortie publiée de l'étape de build vers l'image finale
- Assurez-vous de tenir compte de toutes les exigences dans les paramètres de containerisation :
  - Version .NET et distribution Linux
  - Ports exposés
  - Compte utilisateur pour le conteneur
  - Configuration ASPNETCORE_URLS
  - Installation des packages système
  - Dépendances de bibliothèques natives
  - Outils .NET supplémentaires
  - Variables d'environnement
  - Copie de fichiers/répertoires
  - Points de montage de volume
  - Configuration du health check
Créez un fichier .dockerignore à la racine du répertoire du projet pour exclure les fichiers inutiles de l'image Docker. Le fichier .dockerignore DOIT inclure au moins les éléments suivants ainsi que les motifs supplémentaires spécifiés dans les paramètres de containerisation :
- bin/
- obj/
- .dockerignore
- Dockerfile
- .git/
- .github/
- .vs/
- .vscode/
- **/node_modules/
- *.user
- *.suo
- **/.DS_Store
- **/Thumbs.db
- Tout motif supplémentaire spécifié dans les paramètres de containerisation
Configurez les health checks si spécifiés dans les paramètres de containerisation :
- Ajoutez l'instruction HEALTHCHECK au Dockerfile si un endpoint de health check est fourni
- Utilisez curl ou wget pour vérifier l'endpoint de santé
Marquez les tâches comme terminées : [ ] → [✓]
Continuez jusqu'à ce que toutes les tâches soient terminées et que la build Docker réussisse

Vérification de la Build et du Runtime

Confirmez que la build Docker réussit une fois le Dockerfile complété. Utilisez la commande suivante pour construire l'image Docker :

docker build -t aspnetcore-app:latest .

Si la build échoue, examinez les messages d'erreur et apportez les ajustements nécessaires au Dockerfile ou à la configuration du projet. Signalez la réussite ou l'échec.

Suivi de la Progression

Maintenez un fichier progress.md avec la structure suivante :

# Progression de la Containerisation

## Détection de l'Environnement
- [ ] Détection de la version .NET (version : ___)
- [ ] Sélection de la distribution Linux (distribution : ___)

## Modifications de Configuration
- [ ] Vérification de la configuration de l'application pour le support des variables d'environnement
- [ ] Configuration de la source de packages NuGet (le cas échéant)

## Containerisation
- [ ] Création du Dockerfile
- [ ] Création du fichier .dockerignore
- [ ] Étape de build créée avec l'image SDK
- [ ] Fichier(s) csproj copiés pour la restauration des packages
- [ ] NuGet.config copié le cas échéant
- [ ] Étape runtime créée avec l'image runtime
- [ ] Configuration utilisateur non-root
- [ ] Gestion des dépendances (packages système, bibliothèques natives, outils, etc.)
- [ ] Configuration du health check (le cas échéant)
- [ ] Implémentation des exigences spéciales

## Vérification
- [ ] Examinez les paramètres de containerisation et assurez-vous que toutes les exigences sont respectées
- [ ] Succès de la build Docker

Ne mettez pas en pause pour demander une confirmation entre les étapes. Continuez méthodiquement jusqu'à ce que l'application soit containerisée et que la build Docker réussisse.

VOUS N'AVEZ PAS TERMINÉ TANT QUE TOUTES LES CASES NE SONT PAS COCHÉES ! Cela inclut la construction réussie de l'image Docker et la résolution de tous les problèmes qui surviennent au cours du processus de build.

Exemple de Dockerfile

Un exemple de Dockerfile pour une application ASP.NET Core (.NET) utilisant une image de base Linux.

# ============================================================
# Étape 1 : Compilation et publication de l'application
# ============================================================

# Image de base - Sélectionnez la version appropriée du .NET SDK et la distribution Linux
# Les balises possibles incluent :
# - 8.0-bookworm-slim (Debian 12)
# - 8.0-noble (Ubuntu 24.04)
# - 8.0-alpine (Alpine Linux)
# - 9.0-bookworm-slim (Debian 12)
# - 9.0-noble (Ubuntu 24.04)
# - 9.0-alpine (Alpine Linux)
# Utilise l'image .NET SDK pour compiler l'application
FROM mcr.microsoft.com/dotnet/sdk:8.0-bookworm-slim AS build
ARG BUILD_CONFIGURATION=Release

WORKDIR /src

# Copiez d'abord les fichiers de projet pour un meilleur caching
COPY ["YourProject/YourProject.csproj", "YourProject/"]
COPY ["YourOtherProject/YourOtherProject.csproj", "YourOtherProject/"]

# Copiez la configuration NuGet si elle existe
COPY ["NuGet.config", "."]

# Restaurez les packages NuGet
RUN dotnet restore "YourProject/YourProject.csproj"

# Copiez le code source
COPY . .

# Effectuez les étapes de pré-build personnalisées ici, si nécessaire
# RUN echo "Exécution des étapes de pré-build..."

# Compilez et publiez l'application
WORKDIR "/src/YourProject"
RUN dotnet build "YourProject.csproj" -c $BUILD_CONFIGURATION -o /app/build

# Publiez l'application
RUN dotnet publish "YourProject.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

# Effectuez les étapes de post-build personnalisées ici, si nécessaire
# RUN echo "Exécution des étapes de post-build..."

# ============================================================
# Étape 2 : Image runtime finale
# ============================================================

# Image de base - Sélectionnez la version appropriée du runtime .NET et la distribution Linux
# Les balises possibles incluent :
# - 8.0-bookworm-slim (Debian 12)
# - 8.0-noble (Ubuntu 24.04)
# - 8.0-alpine (Alpine Linux)
# - 8.0-noble-chiseled (Ubuntu 24.04 Chiseled)
# - 8.0-azurelinux3.0 (Azure Linux)
# - 9.0-bookworm-slim (Debian 12)
# - 9.0-noble (Ubuntu 24.04)
# - 9.0-alpine (Alpine Linux)
# - 9.0-noble-chiseled (Ubuntu 24.04 Chiseled)
# - 9.0-azurelinux3.0 (Azure Linux)
# Utilise l'image runtime .NET pour exécuter l'application
FROM mcr.microsoft.com/dotnet/aspnet:8.0-bookworm-slim AS final

# Installez les packages système si nécessaire (décommentez et modifiez le cas échéant)
# RUN apt-get update && apt-get install -y \
#     curl \
#     wget \
#     ca-certificates \
#     libgdiplus \
#     && rm -rf /var/lib/apt/lists/*

# Installez les outils .NET supplémentaires si nécessaire (décommentez et modifiez le cas échéant)
# RUN dotnet tool install --global dotnet-ef --version 8.0.0
# ENV PATH="$PATH:/root/.dotnet/tools"

WORKDIR /app

# Copiez l'application publiée à partir de l'étape de build
COPY --from=build /app/publish .

# Copiez les fichiers supplémentaires si nécessaire (décommentez et modifiez le cas échéant)
# COPY ./config/appsettings.Production.json .
# COPY ./certificates/ ./certificates/

# Définissez les variables d'environnement
ENV ASPNETCORE_ENVIRONMENT=Production
ENV ASPNETCORE_URLS=http://+:8080

# Ajoutez des variables d'environnement personnalisées si nécessaire (décommentez et modifiez le cas échéant)
# ENV CONNECTIONSTRINGS__DEFAULTCONNECTION="votre-chaîne-de-connexion"
# ENV FEATURE_FLAG_ENABLED=true

# Configurez les certificats SSL/TLS si nécessaire (décommentez et modifiez le cas échéant)
# ENV ASPNETCORE_Kestrel__Certificates__Default__Path=/app/certificates/app.pfx
# ENV ASPNETCORE_Kestrel__Certificates__Default__Password=votre_mot_de_passe

# Exposez le port sur lequel l'application écoute
EXPOSE 8080
# EXPOSE 8081  # Décommentez si vous utilisez HTTPS

# Installez curl pour les health checks s'il n'est pas déjà présent
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

# Configurez le health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1

# Créez des volumes pour les données persistantes si nécessaire (décommentez et modifiez le cas échéant)
# VOLUME ["/app/data", "/app/logs"]

# Basculez vers un utilisateur non-root pour la sécurité
USER $APP_UID

# Définissez le point d'entrée pour l'application
ENTRYPOINT ["dotnet", "YourProject.dll"]

Adaptation de cet Exemple

Note : Personnalisez ce modèle en fonction des exigences spécifiques dans les paramètres de containerisation.

Lors de l'adaptation de cet exemple de Dockerfile :

Remplacez YourProject.csproj, YourProject.dll, etc. par les noms de vos projets réels
Ajustez la version .NET et la distribution Linux selon vos besoins
Modifiez les étapes d'installation des dépendances en fonction de vos exigences et supprimez les étapes inutiles
Configurez les variables d'environnement spécifiques à votre application
Ajoutez ou supprimez des étapes selon les besoins de votre flux de travail spécifique
Mettez à jour l'endpoint du health check pour qu'il corresponde à l'itinéraire du health check de votre application

Variations de Distribution Linux

Alpine Linux

Pour des tailles d'image plus petites, vous pouvez utiliser Alpine Linux :

FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build
# ... étapes de build ...

FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine AS final
# Installez les packages avec apk
RUN apk update && apk add --no-cache curl ca-certificates

Ubuntu Chiseled

Pour une surface d'attaque minimale, envisagez d'utiliser des images chiseled :

FROM mcr.microsoft.com/dotnet/aspnet:8.0-jammy-chiseled AS final
# Note : Les images chiseled ont des packages minimaux, vous devrez peut-être utiliser une base différente pour les dépendances supplémentaires

Azure Linux (Mariner)

Pour les conteneurs optimisés pour Azure :

FROM mcr.microsoft.com/dotnet/aspnet:8.0-azurelinux3.0 AS final
# Installez les packages avec tdnf
RUN tdnf update -y && tdnf install -y curl ca-certificates && tdnf clean all

Notes sur la Dénomination des Étapes

La syntaxe AS nom-etape donne un nom à chaque étape
Utilisez --from=nom-etape pour copier les fichiers à partir d'une étape précédente
Vous pouvez avoir plusieurs étapes intermédiaires qui ne sont pas utilisées dans l'image finale
L'étape final est celle qui devient l'image de conteneur finale

Meilleures Pratiques de Sécurité

Exécutez toujours en tant qu'utilisateur non-root en production
Utilisez des balises d'image spécifiques plutôt que latest
Réduisez au minimum le nombre de packages installés
Gardez les images de base à jour
Utilisez des builds multi-étapes pour exclure les dépendances de build de l'image finale

containerize-aspnetcore