Comment exécuter Aspose.HTML dans Docker – Exécuter la conversion et le traitement HTML n'importe où

Conteneur Docker

Docker est une plateforme open-source populaire qui vous permet d’automatiser le déploiement et la gestion d’applications dans des conteneurs. Les conteneurs présentent de nombreuses caractéristiques et avantages : ils offrent un environnement léger et isolé pour l’exécution des applications et leur permettent de fonctionner de manière cohérente sur différents systèmes d’exploitation et infrastructures.

Le conteneur est comme une machine virtuelle. Il peut être installé, supprimé, arrêté, repris ou connecté au terminal. Le conteneur docker est donc un logiciel exécutable léger et autonome qui comprend tout ce qui est nécessaire à l’exécution d’une application : le code, le moteur d’exécution, les outils système, les bibliothèques système et les paramètres.

Dans cet article, nous verrons comment conteneuriser une application .NET avec Docker et intégrer la fonctionnalité Aspose.HTML dans votre projet. Vous trouverez ici des instructions pas à pas sur la manière d’exécuter Aspose.HTML dans Docker – comment créer une application console et configurer un fichier Docker.

Configuration requise

Avant de pouvoir exécuter Aspose.HTML dans Docker, vous devez installer Docker sur votre système. Pour installer Docker Desktop avec succès, vous devez vous assurer que votre système répond à la configuration minimale requise pour l’installation de Docker. Pour plus d’informations sur l’installation de Docker sur Windows, Mac ou Linux, suivez les liens :

• Installer Docker Desktop sur Windows
• Installer Docker Desktop sur Mac
• Installer Docker Desktop sur Linux

Comment créer une application console avec le support de Docker

Prenons un exemple : nous créons une simple Application console ConsoleApp qui convertit un document HTML (document.html) et le sauvegarde au format TIFF. Cette application peut être compilée et exécutée dans Docker. Pour créer un projet d’application console, suivez quelques étapes :

1. Ouvrez un Visual Studio (Visual Studio 2022 est utilisé dans l’exemple), et à l’étape “Create a new project”, sélectionnez une Console App C#.

2. Laissez le répertoire et les paramètres du projet de l’application console par défaut (comme dans l’exemple), ou indiquez les vôtres :

3. Choisissez .NET 6.0 (Long-term support) dans le menu Framework.

4. Ajoutez la prise en charge de Docker au projet et sélectionnez le système d’exploitation Linux cible.

Après avoir ajouté la prise en charge de Docker, un fichier Docker est créé avec le contenu par défaut.

Comment configurer un fichier Docker

En configurant correctement le fichier Docker, vous pouvez définir les étapes de construction d’une image Docker et créer un environnement conteneurisé qui inclut toutes les dépendances et configurations nécessaires à l’exécution de votre application.

1. Voici le contenu du fichier Docker par défaut :

#See https://aka.ms/containerfastmode to understand how Visual Studio uses this Dockerfile to build your images for faster debugging.

FROM mcr.microsoft.com/dotnet/runtime:6.0 AS base
WORKDIR /app

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["ConsoleApp/ConsoleApp.csproj", "ConsoleApp/"]
RUN dotnet restore "ConsoleApp/ConsoleApp.csproj"
COPY . .
WORKDIR "/src/ConsoleApp"
RUN dotnet build "ConsoleApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "ConsoleApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "ConsoleApp.dll"]

2. Vous devez modifier le fichier Dockerfile, installer les polices nécessaires et configurer la prise en charge de l’encodage UTF-8.

# See https://aka.ms/customizecontainer to learn how to customize your debug container and how Visual Studio uses this Dockerfile to build your images for faster debugging.

# ---------- Base runtime stage ----------
# .NET runtime + font and globalization support
FROM mcr.microsoft.com/dotnet/runtime:6.0 AS base
WORKDIR /app

# Install fonts, fontconfig, locale support, and CA certificates
RUN apt-get update && apt-get install -y --no-install-recommends \
        libc6-dev \
        libgdiplus \
        fontconfig \
        fonts-dejavu-core \
        fonts-dejavu-extra \
        fonts-liberation \
        fonts-freefont-ttf \
        locales \
        ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# Enable and generate UTF-8 locale
RUN sed -i 's/# \(en_US.UTF-8 UTF-8\)/\1/' /etc/locale.gen \
    && locale-gen

# Configure globalization
ENV LANG=en_US.UTF-8 \
    LANGUAGE=en_US:en \
    LC_ALL=en_US.UTF-8 \
    DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=false

# Build font cache (useful for predictable font discovery)
RUN fc-cache -f -v

# ---------- Build stage ----------
# Restore and build the application
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["ConsoleApp/ConsoleApp.csproj", "ConsoleApp/"]
RUN dotnet restore "ConsoleApp/ConsoleApp.csproj"
COPY . .
WORKDIR "/src/ConsoleApp"
RUN dotnet build "ConsoleApp.csproj" -c Release -o /app/build

# ---------- Publish stage ----------
FROM build AS publish
RUN dotnet publish "ConsoleApp.csproj" -c Release -o /app/publish /p:UseAppHost=false

# ---------- Final runtime stage ----------
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "ConsoleApp.dll"]

Un Dockerfile est un fichier texte qui contient un ensemble d’instructions utilisées pour construire une image Docker. Il peut être divisé en quatre blocs distincts : base runtime stage, build stage, publish stage, et final runtime stage. Passons en revue les étapes d’un fichier Docker et leur signification :

1. Le base runtime stage fournit l’environnement d’exécution et installe les dépendances nécessaires à la gestion des polices et au rendu des images dans le conteneur.

• Le mot clé FROM nécessite un nom d’image de conteneur Docker entièrement qualifié. Dans la première ligne, l’image de base mcr.microsoft.com/dotnet/runtime:6.0 est spécifiée. Cette image de base fournit l’environnement d’exécution pour les applications .NET.
• La commande WORKDIR définit le répertoire de travail à l’intérieur du docker à /app.
• Les commandes RUN mettent à jour les listes de paquets, installent les dépendances d’exécution natives (libc6-dev, libgdiplus), fontconfig et les paquets de polices open-source, la prise en charge des paramètres régionaux et les certificats CA, configurent les paramètres de globalisation UTF-8 pour .NET, reconstruisent le cache de polices et nettoient le cache de paquets afin de minimiser la taille de l’image.

2. Le build stage regroupe les étapes de restauration des dépendances et de compilation de l’application .NET.

• La commande FROM spécifie l’image de base mcr.microsoft.com/dotnet/sdk:6.0. Le segment dotnet est le référentiel du conteneur, tandis que le segment sdk est le nom de l’image du conteneur docker. L’image inclut le SDK .NET 6.0, ce qui vous permet de créer votre application .NET.
• L’instruction WORKDIR définit le répertoire de travail à l’intérieur du conteneur à /src.
• La commande COPY copie le fichier de projet ConsoleApp.csproj du répertoire local ConsoleApp/ vers le répertoire /src/ConsoleApp/ du conteneur.
• La commande RUN effectue une restauration dotnet pour restaurer les paquets NuGet du projet.
• La commande COPY demande à docker de copier le dossier spécifié sur votre ordinateur dans un dossier du conteneur docker – /scr/.
• La commande RUN dotnet build "ConsoleApp.csproj" -c Release -o /app/build compile l’application .NET spécifiée dans ConsoleApp.csproj en utilisant la configuration Release et stocke la sortie de la compilation dans le répertoire /app/build à l’intérieur du conteneur.

3. Le publish stage déclare l’application pour le déploiement.

• La ligne FROM build AS publish met en place un nouveau stage d’image docker nommé publish basé sur le stage build précédent. Cela indique que l’étape publish héritera de tous les fichiers, dépendances et configurations de l’étape build.
• La commande RUN exécute dotnet publish pour publier l’application dans la configuration Release, le répertoire de sortie étant /app/publish.

4. Le final runtime stage exécute l’application au démarrage du conteneur docker.

• L’instruction FROM utilise l’étape base comme image de base.
• La commande WORKDIR change le répertoire courant à l’intérieur du conteneur en /app.
• La commande COPY demande au docker de copier les fichiers publiés depuis l’étape publish vers le répertoire courant de l’étape final.
• La commande ENTRYPOINT est utilisée pour lancer un fichier exécutable, qui est ConsoleApp.dll.

Ces quatre blocs du fichier Docker fonctionnent ensemble pour construire une image Docker en plusieurs étapes. Les étapes initiales de base et de construction sont utilisées pour installer les dépendances, restaurer les paquets et construire l’application. La publication suivante et les blocs finaux sont utilisés pour publier l’application en vue de son déploiement et de son exécution lorsque le conteneur démarre.

Exemple d’application console

Dans l’exemple, nous proposons d’utiliser un programme simple qui convertit un document HTML en format d’image TIFF :

using Aspose.Html;
using Aspose.Html.Rendering.Image;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            using var doc = new HTMLDocument("document.html");
            using var dev = new ImageDevice(new ImageRenderingOptions(ImageFormat.Tiff), "result.tiff");
            doc.RenderTo(dev);
        }
    }
}

Configurer l’application console et exécuter Aspose.HTML dans Docker

1. Pour exécuter Aspose.HTML dans Docker, installez la dernière version d’Aspose.HTML et System.Drawing.Common 6.0 à partir de NuGet.

2. Editez le projet ConsoleApp.csproj – ajoutez l’option InvariantGlobalization = false :

Le fichier suivant est un fichier de projet .NET qui définit les paramètres du projet, les dépendances et les fichiers supplémentaires nécessaires pour créer une application exécutable. <InvariantGlobalization> est un élément supplémentaire qui désactive le comportement de globalisation invariante dans le projet. S’il vaut false, le projet utilisera le comportement de globalisation par défaut.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Aspose.HTML" Version="23.5.0" />
    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.14.0" />
    <PackageReference Include="System.Drawing.Common" Version="6.0.0" />
  </ItemGroup>

  <ItemGroup>
    <None Update="document.html">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
  </ItemGroup>

  <ItemGroup>
    <RuntimeHostConfigurationOption Include="System.Drawing.EnableUnixSupport" Value="true" />
  </ItemGroup>
  
  <PropertyGroup>
	  <InvariantGlobalization>false</InvariantGlobalization>
  </PropertyGroup>

</Project>

3. Définissez la propriété “Сopy to Output Directory” pour le fichier converti :

4. Lorsque toutes les dépendances et propriétés requises sont ajoutées, exécutez la conversion HTML to TIFF pour Linux dans un conteneur Docker en cliquant sur le bouton vert.

Aide et soutien

Si vous avez besoin d’aide ou si vous avez des questions sur l’exécution d’Aspose.HTML dans Docker, veuillez contacter Free Support Forum ou Free Consulting. Nous serons heureux de vous aider !

Voir aussi

• Informations sur le SDK .NET Core
• Tutoriel : Containeriser une application .NET
• Docker Desktop