Wie man Aspose.HTML in Docker ausführt

Docker-Container

Docker ist eine beliebte Open-Source-Plattform, mit der Sie die Bereitstellung und Verwaltung von Anwendungen in Containern automatisieren können. Container haben viele Funktionen und Vorteile. Sie bieten eine leichtgewichtige und isolierte Umgebung für die Ausführung von Anwendungen und ermöglichen deren konsistente Nutzung auf verschiedenen Betriebssystemen und Infrastrukturen.

Der Container ist wie eine virtuelle Maschine. Er kann installiert, gelöscht, gestoppt, wiederaufgenommen oder mit dem Terminal verbunden werden. Der Docker-Container ist also ein leichtgewichtiges, in sich geschlossenes, ausführbares Softwarepaket, das alles enthält, was zur Ausführung einer Anwendung erforderlich ist: Code, Laufzeit, Systemtools, Systembibliotheken und Einstellungen.

In diesem Artikel sehen wir uns an, wie man eine .NET-Anwendung mit Docker containerisiert und Aspose.HTML-Funktionalität in Ihr Projekt integriert. Hier finden Sie eine Schritt-für-Schritt-Anleitung, wie Sie Aspose.HTML in Docker ausführen können – wie Sie eine Konsolenanwendung erstellen und ein Dockerfile einrichten.

Systemvoraussetzungen

Bevor Sie Aspose.HTML in Docker ausführen können, müssen Sie Docker auf Ihrem System installiert haben. Um Docker Desktop erfolgreich zu installieren, sollten Sie sicherstellen, dass Ihr System die Mindestanforderungen für die Installation von Docker erfüllt. Für Informationen über die Installation von Docker unter Windows, Mac oder Linux folgen Sie den Links:

• Docker Desktop unter Windows installieren
• Docker Desktop auf dem Mac installieren
• Docker-Desktop unter Linux installieren

Wie man eine Konsolenanwendung mit Docker-Unterstützung erstellt

Betrachten wir das Beispiel: Wir erstellen eine einfache Konsolenanwendung ConsoleApp, die ein HTML-Dokument (document.html) konvertiert und im TIFF-Format speichert. Diese Anwendung können Sie in Docker erstellen und ausführen. Um ein Projekt für eine Konsolenanwendung zu erstellen, führen Sie einige Schritte aus:

1. Öffnen Sie ein Visual Studio (im Beispiel wird Visual Studio 2022 verwendet), und wählen Sie auf der Stufe “Create a new project” eine Console App C#.

2. Belassen Sie das Verzeichnis und die Parameter für das Konsolenanwendungsprojekt in der Voreinstellung (wie im Beispiel), oder geben Sie Ihre eigenen an:

3. Wählen Sie .NET 6.0 (Langzeitunterstützung) aus dem Menü Framework aus.

4. Fügen Sie dem Projekt Docker-Unterstützung hinzu und wählen Sie das Ziel-Linux-Betriebssystem.

Nach dem Hinzufügen der Dockerunterstützung wird eine Dockerdatei mit Standardinhalt erstellt.

Konfigurieren eines Dockerfiles

Durch die korrekte Konfiguration des Dockerfiles können Sie die Schritte zur Erstellung eines Docker-Images definieren und eine containerisierte Umgebung erstellen, die alle notwendigen Abhängigkeiten und Konfigurationen zur Ausführung Ihrer Anwendung enthält.

1. Hier ist der Standardinhalt des Dockerfiles:

#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. Sie müssen die Dockerdatei bearbeiten und libgdiplus, die erforderlichen Bibliotheken und Schriftarten installieren.

#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"]

Ein Dockerfile ist eine Textdatei, die eine Reihe von Anweisungen enthält, die zum Erstellen eines Docker-Images verwendet werden. Sie kann in vier verschiedene Blöcke unterteilt werden: docker base image, docker build image, docker publish image und docker final image. Gehen wir die Schritte in einer Dockerdatei und ihre Bedeutung durch:

1. Das docker base image definiert das Basis-Image und installiert die notwendigen Abhängigkeiten, die für den Umgang mit Bildern und Schriftarten im Container benötigt werden.

• Das Schlüsselwort FROM erfordert einen vollständig qualifizierten Namen des Docker-Container-Abbilds. In der ersten Zeile wird das Basis-Image als mcr.microsoft.com/dotnet/runtime:6.0 angegeben. Dieses Basis-Image stellt die Laufzeitumgebung für .NET-Anwendungen bereit.
• Der Befehl WORKDIR setzt das Arbeitsverzeichnis innerhalb des Docker auf /app.
• Die RUN-Befehle aktualisieren die Paketlisten, installieren die erforderlichen Pakete libgdiplus, libc6-dev, ttf-mscorefonts-installer und fontconfig und bereinigen anschließend den Paket-Cache.

2. Das docker build image enthält die Anweisungen zum Erstellen von .NET-Anwendungen.

• Der FROM-Befehl gibt das Basis-Image mcr.microsoft.com/dotnet/sdk:6.0 an. Das Segment “dotnet” ist das Container-Repository, während das Segment sdk der Name des Docker-Container-Images ist. Das Image enthält das .NET 6.0 SDK, mit dem Sie Ihre .NET-Anwendung erstellen können.
• Die Anweisung WORKDIR setzt das Arbeitsverzeichnis innerhalb des Containers auf /src.
• Der Befehl COPY kopiert die Projektdatei ConsoleApp.csproj aus dem lokalen Verzeichnis ConsoleApp/ in das Verzeichnis /src/ConsoleApp/ des Containers.
• Der RUN-Befehl führt einen dotnet restore aus, um die NuGet-Pakete für das Projekt wiederherzustellen.
• Der Befehl COPY weist Docker an, den angegebenen Ordner auf Ihrem Computer in einen Ordner im Docker-Container zu kopieren - /scr/.
• Der Befehl RUN dotnet build "ConsoleApp.csproj" -c Release -o /app/build kompiliert die in ConsoleApp.csproj angegebene .NET-Anwendung unter Verwendung der Release-Konfiguration und speichert die Build-Ausgabe im Verzeichnis /app/build im Container.

3. Das docker publish image deklariert die Anwendung für die Bereitstellung.

• Die Zeile FROM build AS publish richtet eine neue Docker-Image-Stufe namens publish ein, die auf der vorherigen build-Stufe basiert. Dies bedeutet, dass die Stufe publish alle Dateien, Abhängigkeiten und Konfigurationen von der Stufe build erben wird.
• Der RUN-Befehl führt dotnet publish aus, um die Anwendung in der Konfiguration Release zu veröffentlichen, wobei das Ausgabeverzeichnis als /app/publish festgelegt wird.

4. Das docker final image führt die Anwendung aus, wenn der Docker-Container startet.

• Die FROM-Anweisung verwendet die Stufe base als Basis-Image.
• Der Befehl WORKDIR ändert das aktuelle Verzeichnis innerhalb des Containers in /app.
• Der COPY-Befehl weist den Docker an, die veröffentlichten Dateien aus der publish-Stufe in das aktuelle Verzeichnis in der final-Stufe zu kopieren.
• Der Befehl ENTRYPOINT wird verwendet, um eine ausführbare Datei auszuführen, nämlich ConsoleApp.dll.

Diese vier Blöcke im Dockerfile arbeiten zusammen, um ein mehrstufiges Docker-Image zu erstellen. Die anfängliche Base- und Build-Phase wird verwendet, um Abhängigkeiten zu installieren, Pakete wiederherzustellen und die Anwendung zu erstellen. Die nächsten Blöcke “publish” und “final” werden für die Veröffentlichung der Anwendung für die Bereitstellung und die Ausführung beim Start des Containers verwendet.

Beispiel für eine Konsolenanwendung

In diesem Beispiel wird ein einfaches Programm vorgeschlagen, das ein HTML-Dokument in ein TIFF-Bildformat konvertiert:

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);
        }
    }
}

Konfigurieren der Konsolenanwendung und Ausführen von Aspose.HTML in Docker

1. Um Aspose.HTML in Docker auszuführen, installieren Sie die neueste Aspose.HTML-Version und System.Drawing.Common 6.0 aus NuGet.

2. Bearbeiten Sie das Projekt ConsoleApp.csproj - fügen Sie die Option InvariantGlobalization = false hinzu:

Die folgende Datei ist eine .NET-Projektdatei, die die Projekteinstellungen, Abhängigkeiten und zusätzlichen Dateien definiert, die zum Erstellen einer ausführbaren Anwendung erforderlich sind. <InvariantGlobalization> ist ein zusätzliches Element, das das invariante Globalisierungsverhalten im Projekt deaktiviert. Wenn es auf false gesetzt ist, verwendet das Projekt das Standard-Globalisierungsverhalten.

<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. Setzen Sie die Eigenschaft “Сopy to Output Directory” für die konvertierte Datei:

4. Wenn alle erforderlichen Abhängigkeiten und Eigenschaften hinzugefügt sind, führen Sie die HTML-zu-TIFF-Konvertierung für Linux in einem Docker-Container aus, indem Sie auf die grüne Schaltfläche klicken.

Hilfe & Support

Wenn Sie Hilfe benötigen oder Fragen zum Betrieb von Aspose.HTML in Docker haben, wenden Sie sich bitte an Free Support Forum oder Free Consulting. Wir helfen Ihnen gerne weiter!

Siehe auch

• Informationen zum .NET Core SDK
• Tutorial: Eine .NET-Anwendung containerisieren
• Docker Desktop