Hur man kör Aspose.Cells i Docker

Microservices, i kombination med containerisering, gör det möjligt att enkelt kombinera teknologier. Docker gör det möjligt att enkelt integrera Aspose.Cells-funktionalitet i din applikation, oavsett vilken teknik som finns i din utvecklingsstack.

Om du riktar in dig på mikrotjänster eller om huvudtekniken i din stack inte är .NET, C++ eller Java, men du behöver funktionaliteten i Aspose.Cells, eller om du redan använder Docker i din stack, kan du vara intresserad av att använda Aspose.Cells i en Docker-container.

Förutsättningar

Docker måste vara installerat på ditt system. För information om hur man installerar Docker på Windows eller Mac, hänvisas till länkarna i avsnittet “Se även”.
Observera också att Visual Studio 2019, .NET Core 3.1 SDK används i exemplet som anges nedan.

Hello World-applikation

I det här exemplet skapar du en enkel Hello World-konsolapplikation som skapar en ”Hello World!”-dokument och sparar den i alla stödda spara format. Applikationen kan sedan byggas och köras i Docker.

Skapande av konsolapplikationen

För att skapa Hello World-programmet, följ stegen nedan:

När Docker är installerat, se till att det använder Linux-containers (standard). Om det behövs, välj alternativet Växla till Linux-containers från Docker Desktops meny.
In Visual Studio, create a .NET Core console application.
Install the latest Aspose.Cells version from NuGet. System.Drawing.Common and System.Text.Encoding.CodePages will be installed as a dependency of Aspose.Cells.
Eftersom programmet kommer att köras på Linux måste de lämpliga nativa Linux-resurserna installeras. Börja med dotnet core sdk 3.1-basbilden och installera libgdiplus libc6-dev.

When all required dependencies are added, write a simple program that creates a “Hello World!” workbook and saves it in all supported save formats:
.NET

using System;
namespace Aspose.Cells.Docker
{
    class Program
    {
        static void Main(string[] args)
        {
            Workbook workbook = new Workbook();
            workbook.Worksheets[0].Cells[0, 0].PutValue("Hello from Aspose.Cells!!!");
            foreach (SaveFormat sf in Enum.GetValues(typeof(SaveFormat)))
            {
                if (sf != SaveFormat.Unknown)
                {
                    try
                    {
                        // The folder specified will be mounted as a volume when run the application in Docker image.
                        var fileName = string.Format("out{0}", FileFormatUtil.SaveFormatToExtension(sf));
                        workbook.Save(fileName, sf);
                        Console.WriteLine("Saving {0}\t\t[OK]", sf);
                    }
                    catch
                    {
                        Console.WriteLine("Saving {0}\t\t[FAILED]", sf);
                    }
                }
            }
        }
    }
}

Observera att mappen “TestOut” anges som en utmatningsmapp för att spara utmatningsdokument. När programmet körs i Docker kommer en mapp på värdmaskinen att monteras till denna mapp i containern. Detta gör att du enkelt kan visa utmatningen genererad av Aspose.Cells i Dockercontainern.

Konfigurering av en Dockerfil

Nästa steg är att skapa och konfigurera Dockerfilen.

Skapa Dockerfilen och placera den bredvid lösningen för din applikation. Behåll filnamnet utan tillägg (standard).
I Dockerfilen, ange:

FROM mcr.microsoft.com/dotnet/core/sdk:3.1-buster 
COPY fonts/* /usr/share/fonts/
WORKDIR /app
COPY . ./
RUN apt-get update && \
    apt-get install -y --allow-unauthenticated libgdiplus libc6-dev
RUN dotnet publish "Aspose.Cells.Docker.csproj" -c Release -o /app/publish
ENTRYPOINT ["dotnet", "publish/Aspose.Cells.Docker.dll"]

Ovan är en enkel Dockerfil som innehåller följande instruktioner:

Den SDK-bild som ska användas. Här är det .Net Core SDK 3.1-bilden. Docker kommer att ladda ner den när byggnaden körs. Versionen av SDK anges som en tagg.
Installera typsnitt eftersom SDK-bilden innehåller väldigt få typsnitt. Kommandot kopierar typsnittsfilerna från lokal till docker-bilden. Se till att du har en lokal “typsnitt”-mapp som innehåller alla typsnitt du behöver installera. I det här exemplet placeras den lokala “typsnitt”-mappen i samma mapp som Dockerfilen.
Arbetskatalogen som anges i nästa rad.
Kommandot för att kopiera allt till containern, publicera applikationen och ange ingångspunkten.
Kommandot för att installera libgdiplus körs i containern. Detta krävs av System.Drawing.Common.

Bygga och köra applikationen i Docker

Nu kan programmet byggas och köras i Docker. Öppna din favoritkommandorad, byt katalog till mappen med applikationen (mapp där lösningen och Dockerfilen är placerade) och kör följande kommando:

docker build -t actest .

Första gången detta kommando körs kan det ta längre tid eftersom Docker behöver ladda ner de nödvändiga bilderna. När det föregående kommandot har utförts kör följande kommando:

docker run --mount type=bind,source=C:\Temp,target=/TestOut --rm actest from Docker

Observera monteringsargumentet, eftersom en mapp på värdmaskinen monteras in i containerns mapp, för att enkelt kunna se resultaten av programkörningen. Sökvägar i Linux skiftlägeskänsliga.

Bilder som stöder Aspose.Cells

Aspose.Cells for .NET Standard stöder inte EMF och TIFF på Linux.

Fler exempel

1. För att köra applikationen i Windows Server 2019

Dockerfile

FROM microsoft/dotnet-framework:4.7.2-sdk-windowsservercore-ltsc2019
WORKDIR /app
COPY . ./
RUN dotnet publish "Aspose.Cells.Docker.csproj" -c Release -o /app/publish
ENTRYPOINT ["dotnet", "publish/Aspose.Cells.Docker.dll"]

Bygg Docker Image

docker build -t actest .

Kör Docker Image

docker run --mount type=bind,source=C:\Temp,target=c:\TestOut --rm actest from Docker

2. För att köra applikationen i Linux

Skriv ett enkelt program som anger typsnittsmappen, skapar en “Hello World!"-arbetsbok och sparar den.

namespace Aspose.Cells.Docker.Fonts
{
    using System;
    using System.IO;

    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // Set font folders on linux.
                string[] fonts = { "/Fonts" };
                FontConfigs.SetFontFolders(fonts, true);
                // build workbook
                Workbook workbook = new Workbook();
                MemoryStream memoryStream = new MemoryStream();
                workbook.Worksheets[0].Cells[0, 0].PutValue("Hello from Aspose.Cells!!!");
                Style style = workbook.CreateStyle();
                style.Font.Name = "Arial";
                style.Font.Size = 16;
                workbook.Worksheets[0].Cells[0, 0].SetStyle(style);
                workbook.Save("/TestOut/TestFontsOut.xlsx");
            }
            catch (Exception e)
            {
                Console.WriteLine("Saving outfonts.xlsx\t\t[FAILED],{0}", e.Message);
            }

        }
    }
}

Dockerfile

FROM mcr.microsoft.com/dotnet/core/sdk:3.1-buster 
WORKDIR /app
COPY . ./
RUN apt-get update && \
    apt-get install -y --allow-unauthenticated libgdiplus libc6-dev
WORKDIR /app
COPY . ./
RUN dotnet publish "Aspose.Cells.Docker.Fonts.csproj" -c Release -o /app/publish
ENTRYPOINT ["dotnet", "publish/Aspose.Cells.Docker.Fonts.dll"]

Bygg Docker Image

docker build -t actest .

Kör Docker Image

docker run --mount type=bind,source=C:\Windows\Fonts,target=/Fonts  --mount type=bind,source=C:\Temp,target=/TestOut --rm actest from Docker

Rekommenderad lösning

För .Net6 (eller senare) plattformar, jämfört med tidigare plattformar (.netcore31 eller tidigare) är en viktig skillnad gällande grafikbiblioteket. I detta officiella Microsoft-dokument förklaras det att för .Net6 eller senare versioner kommer grafikbiblioteket “System.Drawing.Common” endast stödjas på Windows och ger rekommendationer om att ersätta grafikbiblioteket.

Så Aspose.Cells erbjuder en lösning som är beroende av SkiaSharp-ritbiblioteket på icke-Windows plattformar. Vi rekommenderar att använda SkiaSharp som bibliotek på macOS, vilket också innebär att det inte är nödvändigt att installera libgdiplus.

För information om hur man installerar Aspose.Cells på icke-Windows plattformar och använder SkiaSharp som grafikbibliotek, hänvisar vi till följande artikel: Hur man kör Aspose.Cells för .Net6

Se även

Installera Docker Desktop på Windows
Installera Docker Desktop på Mac
Visual Studio 2019, .NET Core 3.1 SDK
Byt till Linux-containrar-alternativet
Ytterligare information om .NET Core SDK

Hur man kör Aspose.Cells i Blazor Hur man kör exemplen