Cómo ejecutar Aspose.HTML for .NET en Docker

Contenedor acoplable

Docker es una popular plataforma de código abierto que le permite automatizar la implementación y administración de aplicaciones dentro de contenedores. Los contenedores tienen muchas características y beneficios, ya que brindan un entorno liviano y aislado para ejecutar aplicaciones y les permiten trabajar de manera consistente en diferentes sistemas operativos e infraestructuras.

El contenedor es como una máquina virtual. Se puede instalar, eliminar, detener, reanudar o conectar al terminal. Por lo tanto, el contenedor Docker es un paquete de software ejecutable, liviano y autónomo que incluye todo lo necesario para ejecutar una aplicación: código, tiempo de ejecución, herramientas del sistema, bibliotecas del sistema y configuraciones.

En este artículo, veremos cómo contener una aplicación .NET con Docker e integrar la funcionalidad Aspose.HTML en su proyecto. Aquí encontrará instrucciones paso a paso sobre cómo ejecutar Aspose.HTML en Docker: cómo crear una aplicación de consola y configurar un Dockerfile.

Requisitos del sistema

Antes de poder ejecutar Aspose.HTML en Docker, debe tener Docker instalado en su sistema. Para instalar Docker Desktop correctamente, debe asegurarse de que su sistema cumpla con los requisitos mínimos para la instalación de Docker. Para obtener información sobre cómo instalar Docker en Windows, Mac o Linux, siga los enlaces:

• Instalar Docker Desktop en Windows
• Instalar Docker Desktop en Mac
• Instalar Docker Desktop en Linux

Cómo crear una aplicación de consola con soporte Docker

Consideremos el ejemplo: creamos una Aplicación de consola ConsoleApp simple que convierte un documento HTML (document.html) y lo guarda en formato TIFF. Esta aplicación se puede compilar y ejecutar en Docker. Para crear un proyecto de aplicación de consola, siga algunos pasos:

1. Abra Visual Studio (en el ejemplo se usa Visual Studio 2022) y en la etapa “Create a new project”, seleccione una Console App C#.

2. Deje el directorio y los parámetros para el proyecto de la aplicación de consola de forma predeterminada (como en el ejemplo) o especifique los suyos propios:

3. Elija .NET 6.0 (soporte a largo plazo) en el menú Framework.

4. Agregue compatibilidad con Docker al proyecto y seleccione el sistema operativo Linux de destino.

Después de agregar compatibilidad con Docker, se crea un Dockerfile con contenido predeterminado.

Cómo configurar un archivo Docker

Al configurar correctamente Dockerfile, puede definir los pasos para crear una imagen de Docker y crear un entorno en contenedores que incluya todas las dependencias y configuraciones necesarias para ejecutar su aplicación.

1. Aquí está el contenido predeterminado de Dockerfile:

#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. Debe editar el Dockerfile, instalar las fuentes necesarias y configurar la compatibilidad con la globalización 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 es un archivo de texto que contiene un conjunto de instrucciones que se utilizan para crear una imagen de Docker. Se puede dividir en cuatro bloques distintos: bloques base runtime stage, build stage, publish stage y final runtime stage. Repasemos los pasos de un Dockerfile y sus significados:

1. La base runtime stage define la imagen base e instala las dependencias necesarias para manejar imágenes y fuentes en el contenedor.

• La palabra clave FROM requiere un nombre de imagen de contenedor acoplable completo. En la primera línea, se especifica la imagen base como mcr.microsoft.com/dotnet/runtime:6.0. Esta imagen base proporciona el entorno de ejecución para aplicaciones .NET.
• El comando WORKDIR establece el directorio de trabajo dentro de la ventana acoplable en /app.
• Los comandos RUN actualizan las listas de paquetes, instalan dependencias de ejecución nativas (libc6-dev, libgdiplus), fontconfig y paquetes de fuentes de código abierto, soporte regional y certificados CA, configuran los ajustes de globalización UTF-8 para .NET, reconstruyen el caché de fuentes y limpian el caché de paquetes para minimizar el tamaño de la imagen.

2. La build stage contiene las instrucciones utilizadas para crear aplicaciones .NET.

• El comando FROM especifica la imagen base mcr.microsoft.com/dotnet/sdk:6.0. El segmento dotnet es el repositorio del contenedor, mientras que el segmento sdk es el nombre de la imagen del contenedor acoplable. La imagen incluye el SDK de .NET 6.0, lo que le permite crear su aplicación .NET.
• La instrucción WORKDIR establece el directorio de trabajo dentro del contenedor en /src.
• El comando COPY copia el archivo de proyecto ConsoleApp.csproj del directorio local ConsoleApp/ al directorio /src/ConsoleApp/ del contenedor.
• El comando RUN realiza una dotnet restore para restaurar los paquetes NuGet para el proyecto.
• El comando COPY le dice a Docker que copie la carpeta especificada en su computadora a una carpeta en el contenedor de Docker: /scr/.
• El comando RUN dotnet build "ConsoleApp.csproj" -c Release -o /app/build compila la aplicación .NET especificada en ConsoleApp.csproj usando la configuración Release y almacena el resultado de la compilación en /app/build dentro del contenedor.

3. La publish stage declara la aplicación para su implementación.

• La línea FROM build AS publish configura una nueva etapa de imagen acoplable llamada publish basada en la etapa anterior build. Esto indica que la etapa publish heredará todos los archivos, dependencias y configuraciones de la etapa build.
• El comando RUN ejecuta dotnet publish para publicar la aplicación en la configuración Release, con el directorio de salida configurado como /app/publish.

4. La final runtime stage ejecuta la aplicación cuando se inicia el contenedor de la ventana acoplable.

• La instrucción FROM utiliza la etapa base como imagen base.
• El comando WORKDIR cambia el directorio actual dentro del contenedor a /app.
• El comando COPY le dice a la ventana acoplable que copie los archivos publicados desde la etapa publish al directorio actual en la etapa final.
• El comando ENTRYPOINT se utiliza para ejecutar un archivo ejecutable, que es ConsoleApp.dll.

Estos cuatro bloques del Dockerfile trabajan juntos para crear una imagen acoplable de varias etapas. Las etapas inicial de base y compilación se utilizan para instalar dependencias, restaurar paquetes y compilar la aplicación. Los siguientes bloques de publish y final se utilizan para publicar la aplicación para su implementación y ejecución cuando se inicia el contenedor.

Ejemplo de aplicación de consola

En el ejemplo, sugerimos utilizar un programa simple que convierte un documento HTML a un formato de imagen 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);
        }
    }
}

Configure la aplicación de consola y ejecute Aspose.HTML en Docker

1. Para ejecutar Aspose.HTML en la ventana acoplable, instale la última versión de Aspose.HTML y System.Drawing.Common 6.0 de NuGet.

2. Edite el proyecto ConsoleApp.csproj; agregue la opción InvariantGlobalization = false:

El siguiente archivo es un archivo de proyecto .NET que define la configuración del proyecto, las dependencias y los archivos adicionales necesarios para crear una aplicación ejecutable. <InvariantGlobalization> es un elemento adicional que deshabilita el comportamiento de globalización invariante en el proyecto. Cuando se establece en falso, el proyecto utilizará el comportamiento de globalización predeterminado.

<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. Configure la propiedad “Сopy to Output Directory” para el archivo convertido:

4. Cuando se agreguen todas las dependencias y propiedades requeridas, ejecute la conversión de HTML a TIFF para Linux en un contenedor acoplable haciendo clic en el botón verde.

Ayuda y soporte

Si necesita ayuda o tiene preguntas sobre cómo ejecutar Aspose.HTML en Docker, comuníquese con el Foro de soporte gratuito o la Consulta gratuita. ¡Estaremos encantados de ayudarte!

Ver también

• Information on .NET Core SDK
• Tutorial: Containerize a .NET app
• Docker Desktop