How to Run Aspose.HTML in Docker – Aspose.HTML for .NET

Docker Container

Docker is a popular open-source platform that allows you to automate the deployment and management of applications within containers. Containers have many features and benefits, providing a lightweight and isolated environment for running applications and allowing them to work consistently across different operating systems and infrastructures.

The container is like a virtual machine. It can be installed, deleted, stopped, resumed, or connected to the terminal. So, the docker container is a lightweight, self-contained executable software package that includes everything needed to run an application: code, runtime, system tools, system libraries, and settings.

In this article, we’ll look at how to containerize a .NET application with docker and integrate Aspose.HTML functionality into your project. Here you will find step-by-step instructions on how to run Aspose.HTML in docker – how to create a console application and set up a Dockerfile.

System Requirements

Before you can run Aspose.HTML in docker, you must have docker installed on your system. To install Docker Desktop successfully, you should ensure that your system meets the minimum requirements for docker installation. For information on how to install docker on Windows, Mac, or Linux follow the links:

• Install Docker Desktop on Windows
• Install Docker Desktop on Mac
• Install Docker Desktop on Linux

How to Create Console Application with Docker Support

Let’s consider the example: we create a simple Console Application ConsoleApp that converts an HTML document (document.html) and saves it in the TIFF format. This application you can build and run in docker. To create a console application project, follow a few steps:

1. Open a Visual Studio (Visual Studio 2022 is used in the example), and on the “Create a new project” stage, select a Console App C#.

2. Leave the directory and parameters for the console application project by default (as in the example), or specify your own:

3. Сhoose the .NET 6.0 (Long-term support) from the Framework menu.

4. Add docker support to the project and select the target Linux OS.

After adding docker support, a Dockerfile is created with default content.

How to Configure a Dockerfile

By properly configuring the Dockerfile, you can define the steps to build a docker image and create a containerized environment that includes all the necessary dependencies and configurations to run your application.

1. Here is the default Dockerfile content:

#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. You need to edit the Dockerfile and install libgdiplus, the required libraries and fonts.

#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.

FROM mcr.microsoft.com/dotnet/runtime:6.0 AS base
WORKDIR /app
RUN apt-get update \
    && apt-get install -y --no-install-recommends libgdiplus libc6-dev \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*
RUN sed -i'.bak' 's/$/ contrib/' /etc/apt/sources.list
RUN apt-get update; apt-get install -y ttf-mscorefonts-installer fontconfig

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 /p:UseAppHost=false

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

A Dockerfile is a text file that contains a set of instructions used to build a docker image. It can be divided into four distinct blocks: docker base image, docker build image, docker publish image, and docker final image blocks. Let’s go through the steps in a Dockerfile and their meanings:

1. The docker base image defines the base image and installs the necessary dependencies needed to handle images and fonts in the container.

• The FROM keyword requires a fully qualified docker container image name. In the first line, the base image as mcr.microsoft.com/dotnet/runtime:6.0 is specified. This base image provides the runtime environment for .NET applications.
• The WORKDIR command sets the working directory inside the docker to /app.
• The RUN commands update the package lists, install the necessary packages libgdiplus, libc6-dev, ttf-mscorefonts-installer, and fontconfig, and then clean up the package cache.

2. The docker build image contains the instructions used for building .NET applications.

• The FROM command specifies the mcr.microsoft.com/dotnet/sdk:6.0 base image. The dotnet segment is the container repository, whereas the sdk segment is the docker container image name. The image includes the .NET 6.0 SDK, allowing you to build your .NET application.
• The WORKDIR instruction sets the working directory inside the container to /src.
• The COPY command copies the project file ConsoleApp.csproj from the local directory ConsoleApp/ to the container’s /src/ConsoleApp/ directory.
• The RUN command performs a dotnet restore to restore the NuGet packages for the project.
• The COPY command tells docker to copy the specified folder on your computer to a folder in the docker container – /scr/.
• The RUN dotnet build "ConsoleApp.csproj" -c Release -o /app/build command compiles the .NET application specified in ConsoleApp.csproj using the Release configuration and stores the build output in the /app/build directory inside the container.

3. The docker publish image declares the application for deployment.

• The FROM build AS publish line sets up a new docker image stage named publish based on the previous build stage. This indicates that the publish stage will inherit all files, dependencies, and configurations from the build stage.
• The RUN command executes dotnet publish to publish the application in the Release configuration, with the output directory set as /app/publish.

4. The docker final image runs the application when the docker container starts.

• The FROM instruction uses the base stage as the base image.
• The WORKDIR command changes the current directory inside of the container to /app.
• The COPY command tells the docker to copy the published files from the publish stage to the current directory in the final stage.
• The ENTRYPOINT command is used to run an executable file, which is ConsoleApp.dll.

These four blocks in the Dockerfile work together to build a multi-stage docker image. The initial base and build stages are used to install dependencies, restore packages, and build the application. The next publish and final blocks are used for publishing the application for deployment and running when the container starts.

Example of Console Application

In the example, we suggest using a simple program that converts an HTML document to a TIFF image format:

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 Console Application and Run Aspose.HTML in Docker

1. To run Aspose.HTML in docker, install the latest Aspose.HTML version and System.Drawing.Common 6.0 from NuGet.

2. Edit the ConsoleApp.csproj project – add the option InvariantGlobalization = false:

The following file is a .NET project file that defines the project settings, dependencies, and additional files needed to create an executable application. <InvariantGlobalization> is an additional element that disables invariant globalization behavior in the project. When set to false, the project will use the default globalization behavior.

<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. Set the “Сopy to Output Directory” property for the converted file:

4. When all required dependencies and properties are added, run the HTML to TIFF conversion for Linux in a docker container by clicking the green button.

Help & Support

If you need help or have questions about running Aspose.HTML in docker, please contact Free Support Forum or Free Consulting. We will be happy to help!

See Also

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