PORóWNANIE

Gotenberg vs IronPDF: Przewodnik po porównaniu technicznym

Zaktualizowano:26 kwietnia, 2026

Kiedy programiści .NET oceniają rozwiązania do generowania plików PDF,Gotenbergwyróżnia się jako mikrousługa oparta na Dockerze, która konwertuje HTML na PDF za pomocą wywołań REST API. ChociażGotenbergmożna dostosować do różnych architektur, wiąże się on ze znacznym obciążeniem infrastruktury — kontenerami Docker, opóźnieniami sieciowymi i złożonością operacyjną.IronPDFoferuje alternatywę: pakiet NuGet działający w tle, zapewniający to samo renderowanie oparte na Chromium bez kontenerów, wywołań sieciowych ani zarządzania infrastrukturą.

W niniejszym porównaniu przeanalizowano oba rozwiązania pod kątem istotnych aspektów technicznych, aby pomóc profesjonalnym programistom i architektom w podjęciu świadomej decyzji dotyczącej ich potrzeb w zakresie obsługi plików PDF w środowisku .NET.

Zrozumienie Gotenberga

Gotenberg to oparta na Dockerze architektura mikrousług do generowania plików PDF. Działa jako oddzielny kontener, który udostępnia punkty końcowe REST API do konwersji HTML, adresów URL i innych formatów do PDF. Każda operacja na pliku PDF wymaga wywołania HTTP do usługi Gotenberg.

Gotenberg używa końcówek jak POST /forms/chromium/convert/html do konwersji HTML na PDF i POST /forms/chromium/convert/url do konwersji URL na PDF. Konfiguracja jest przesyłana przez multipart/form-data ze stringowymi parametrami jak paperWidth, paperHeight, marginTop, oraz marginBottom (w calach). Usługa wymaga wdrożenia Docker, orkiestracji kontenerów (Kubernetes/Docker Compose) oraz infrastruktury sieciowej.

Architektura wymaga:

Wdrażanie i zarządzanie kontenerami Docker
Komunikacja sieciowa dla każdego żądania PDF (kontener HTTP round-trip)
Obsługa zimnego startu kontenera (opóźnienie inicjalizacji dla pierwszych żądań)
Punkty koncowe do sprawdzania stanu zdrowia i monitorowanie uslug
Konstrukcja multipart/form-data dla kazdego zadania

Zrozumienie IronPDF

IronPDF to rodzima biblioteka .NET, która działa w procesie jako pakiet NuGet. Zapewnia renderowanie HTML oparte na Chromium bez uslug zewnętrznych, wywolan sieciowych ani infrastruktury kontenerowej.

IronPDF używa ChromePdfRenderer jako swojej głównej klasy renderującej z metodami takimi jak RenderHtmlAsPdf() i RenderUrlAsPdf(). Konfiguracja używa typowanych właściwości C# na RenderingOptions w tym PaperSize, MarginTop, MarginBottom (w milimetrach). Dokumenty są zapisywane za pomocą SaveAs() lub dostępne jako BinaryData.

Biblioteka wymaga tylko:

Instalacja pakietu NuGet (dotnet add package IronPdf)
Konfiguracji klucza licencyjnego
Standardowej konfiguracji projektu .NET

Porownanie architektury i infrastruktury

Podstawowa roznica miedzy tymi rozwiązaniami lezy w ich wdrożeniu i architekturze podczas uruchomienia.

Czynnik	Gotenberg	IronPDF
Wdrożenie	Kontener Docker + orkiestracja	Pojedynczy pakiet NuGet
Architektura	Mikroserwis (REST API)	Biblioteka w procesie
Opóźnienie na zadanie	Kontener HTTP round-trip	W procesie (minimalne koszty)
Zimny start	Opóźnienie inicjalizacji kontenera	Inicjalizacja silnika (tylko pierwsze renderowanie)
Infrastruktura	Docker, Kubernetes, balansowanie obciazen	Nie wymagana
Zaleznosc sieciowa	Wymagane	None
Tryby awarii	Awaria sieci, kontenera, usługi	Standardowe wyjątki .NET Standard
Styl API	REST multipart/form-data	Oryginalne wywolania metody C#
Skalowanie	Poziome (więcej kontenerow)	Pionowe (w procesie)
Debugowanie	Sledzenie rozproszone	Standardowy debugger
Zarządzanie pamięcią	Osobna alokacja kontenera	Wspoldzielona pamięć aplikacji
Kontrola wersji	Tagi obrazów kontenerow	Wersje pakietow NuGet
Testy stanu	Wymagane punkty koncowe HTTP	Nie potrzebne (w procesie)
Zlozonosc CI/CD	Budowanie kontenerow, przesylki do rejestru	Standardowa budowa .NET

PodejscieGotenbergbazujace na Dockerze wymaga wdrożenia kontenera, monitorowania stanu zdrowia i zarządzania infrastruktura sieciowa.IronPDFcałkowicie eliminuje te warstwe infrastruktury, działajac w procesie.

Porównanie kodu: typowe operacje na plikach PDF

Podstawowa konwersja HTML do PDF

Najbardziej podstawowa operacja wyraznie pokazuje roznice architektoniczna.

Gotenberg:

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergExample
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Hello from Gotenberg</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
        Console.WriteLine("PDF generated successfully");
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergExample
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Hello from Gotenberg</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
        Console.WriteLine("PDF generated successfully");
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Module GotenbergExample
    Async Function Main() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html"

        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()
                Dim html = "<html><body><h1>Hello from Gotenberg</h1></body></html>"
                content.Add(New StringContent(html), "files", "index.html")

                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

                Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                Console.WriteLine("PDF generated successfully")
            End Using
        End Using
    End Function
End Module

$vbLabelText $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var html = "<html><body><h1>Hello from IronPDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF generated successfully");
    }
}

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var html = "<html><body><h1>Hello from IronPDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF generated successfully");
    }
}

Imports System
Imports IronPdf

Class IronPdfExample
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim html = "<html><body><h1>Hello from IronPDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF generated successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

Usługa wymaga utworzenia HttpClient, skonstruowania MultipartFormDataContent, dodania HTML jako załącznika plikowego ze specyficzną nazwą (index.html), wykonania asynchronicznego HTTP POST do końca, odczytania bajtów odpowiedzi i zapisania na dysku. Kazde zadanie przemieszcza sie po sieci, co jest związane z opóźnieniami i trybami awarii.

IronPDF tworzy ChromePdfRenderer, wywołuje RenderHtmlAsPdf() z ciągiem HTML i zapisuje za pomocą SaveAs(). Operacja jest synchronizowana, w procesie, i używa metod typowanych zamiast danych formularzy opartych na tekstach.

Aby uzyskać informacje na temat zaawansowanych opcji renderowania HTML, zapoznaj się z przewodnikiem dotyczącym konwersji HTML do PDF.

Konwersja adresów URL do formatu PDF

Konwersja zywych stron WWW do PDF pokazuje podobne wzorce architektoniczne.

Gotenberg:

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergUrlToPdf
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        content.Add(new StringContent("https://example.com"), "url");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
        Console.WriteLine("PDF from URL generated successfully");
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergUrlToPdf
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        content.Add(new StringContent("https://example.com"), "url");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
        Console.WriteLine("PDF from URL generated successfully");
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Module GotenbergUrlToPdf
    Async Function Main() As Task
        Dim gotenbergUrl As String = "http://localhost:3000/forms/chromium/convert/url"

        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()
                content.Add(New StringContent("https://example.com"), "url")

                Dim response As HttpResponseMessage = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()

                Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                Console.WriteLine("PDF from URL generated successfully")
            End Using
        End Using
    End Function
End Module

$vbLabelText $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfUrlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://example.com");

        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL generated successfully");
    }
}

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfUrlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://example.com");

        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL generated successfully");
    }
}

Imports System
Imports IronPdf

Class IronPdfUrlToPdf
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")

        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL generated successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

Kontener używa końcówki /forms/chromium/convert/url z URL przekazywanym jako dane formularza.IronPDFwywołuje RenderUrlAsPdf() bezpośrednio z ciągiem URL—a pojedyncze wywołanie metody zastępuje infrastrukturę HTTP.

Niestandardowy rozmiar strony i marginesy

Obsluga konfiguracji ujawnia roznice w projektowaniu API.

Gotenberg:

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergCustomSize
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        content.Add(new StringContent("8.5"), "paperWidth");
        content.Add(new StringContent("11"), "paperHeight");
        content.Add(new StringContent("0.5"), "marginTop");
        content.Add(new StringContent("0.5"), "marginBottom");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes);
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergCustomSize
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        content.Add(new StringContent("8.5"), "paperWidth");
        content.Add(new StringContent("11"), "paperHeight");
        content.Add(new StringContent("0.5"), "marginTop");
        content.Add(new StringContent("0.5"), "marginBottom");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes);
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Class GotenbergCustomSize
    Shared Async Function Main() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html"

        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()
                Dim html = "<html><body><h1>Custom Size PDF</h1></body></html>"
                content.Add(New StringContent(html), "files", "index.html")
                content.Add(New StringContent("8.5"), "paperWidth")
                content.Add(New StringContent("11"), "paperHeight")
                content.Add(New StringContent("0.5"), "marginTop")
                content.Add(New StringContent("0.5"), "marginBottom")

                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

                Await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes)
                Console.WriteLine("Custom size PDF generated successfully")
            End Using
        End Using
    End Function
End Class

$vbLabelText $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Rendering;

class IronPdfCustomSize
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("custom-size.pdf");
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Rendering;

class IronPdfCustomSize
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("custom-size.pdf");
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

Imports System
Imports IronPdf
Imports IronPdf.Rendering

Module IronPdfCustomSize

    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 50
        renderer.RenderingOptions.MarginBottom = 50

        Dim html As String = "<html><body><h1>Custom Size PDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("custom-size.pdf")
        Console.WriteLine("Custom size PDF generated successfully")
    End Sub

End Module

$vbLabelText $csharpLabel

To podejście używa stringowych parametrów ("8.5", "11", "0.5") dodawanych do multipart form data. Wymiary papieru sa w całach. Każdy parametr to osobne wywołanie Add() bez sprawdzania typów lub wsparcia IntelliSense.

IronPDF używa typowanych właściwości na RenderingOptions. PaperSize akceptuje enum (PdfPaperSize.Letter), a marginesy to wartości numeryczne w milimetrach. Typowane API zapewnia sprawdzanie w czasie kompilacji i wsparcie IDE.

Dowiedz sie więcej o konfiguracji renderowania w IronPDF tutorials.

Przewodnik po mapowaniu API

Dla deweloperow oceniających migracjeGotenberglub porownujacych możliwosci, to mapowanie pokazuje rownoważne operacje:

Mapowanie punktu koncowego do metody

Trasa Gotenberg	OdpowiednikIronPDF
`POST /forms/chromium/convert/html`	`ChromePdfRenderer.RenderHtmlAsPdf()`
`POST /forms/chromium/convert/url`	`ChromePdfRenderer.RenderUrlAsPdf()`
`POST /forms/chromium/convert/markdown`	Renderowanie Markdown jako HTML najpierw
`POST /forms/pdfengines/merge`	`PdfDocument.Merge()`
`POST /forms/pdfengines/metadata/read`	`pdf.MetaData`
`POST /forms/pdfengines/metadata/write`	`pdf.MetaData.Author = "..."`
`GET /health`	Nie dotyczy

Mapowanie parametru formularza do RenderingOptions

Parametr Gotenberg	WłaściwościIronPDF	Uwagi do konwersji
`paperWidth` (cale)	`RenderingOptions.SetCustomPaperSizeInInches()`	Uzyj metody dla niestandardowego
`paperHeight` (cale)	`RenderingOptions.SetCustomPaperSizeInInches()`	Uzyj metody dla niestandardowego
`marginTop` (cale)	`RenderingOptions.MarginTop`	Pomnoz przez 25,4 dla mm
`marginBottom` (cale)	`RenderingOptions.MarginBottom`	Pomnoz przez 25,4 dla mm
`marginLeft` (cale)	`RenderingOptions.MarginLeft`	Pomnoz przez 25,4 dla mm
`marginRight` (cale)	`RenderingOptions.MarginRight`	Pomnoz przez 25,4 dla mm
`printBackground`	`RenderingOptions.PrintHtmlBackgrounds`	Boolean
`landscape`	`RenderingOptions.PaperOrientation`	`Landscape` enum
`scale`	`RenderingOptions.Zoom`	Procent (100 = 1.0)
`waitDelay`	`RenderingOptions.RenderDelay`	Konwertuj na milisekundy
`emulatedMediaType`	`RenderingOptions.CssMediaType`	`Screen` lub `Print`

Zwróć uwagę na konwersję jednostek:Gotenbergużywa cali dla marginesów (np. "0.5" = 0.5 cala = 12,7mm), podczas gdyIronPDFużywa milimetrów.

Porownanie infrastruktury

GotenbergDocker Compose

Gotenberg wymaga infrastruktury kontenerowej:

#Gotenbergrequires container management
version: '3.8'
services:
  app:
    depends_on:
      - gotenberg
    environment:
      - GOTENBERG_URL=http://gotenberg:3000

  gotenberg:
    image: gotenberg/gotenberg:8
    ports:
      - "3000:3000"
    deploy:
      resources:
        limits:
          memory: 2G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s

#Gotenbergrequires container management
version: '3.8'
services:
  app:
    depends_on:
      - gotenberg
    environment:
      - GOTENBERG_URL=http://gotenberg:3000

  gotenberg:
    image: gotenberg/gotenberg:8
    ports:
      - "3000:3000"
    deploy:
      resources:
        limits:
          memory: 2G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s

YAML

Konfiguracja IronPDF

IronPDF nie wymaga żadnych dodatkowych usług:

#IronPDF- No additional services needed
version: '3.8'
services:
  app:
    environment:
      - IRONPDF_LICENSE_KEY=${IRONPDF_LICENSE_KEY}
# NoGotenbergservice. No health checks. No resource limits.

#IronPDF- No additional services needed
version: '3.8'
services:
  app:
    environment:
      - IRONPDF_LICENSE_KEY=${IRONPDF_LICENSE_KEY}
# NoGotenbergservice. No health checks. No resource limits.

YAML

Różnica w infrastrukturze jest znaczna:Gotenbergwymaga wdrożenia kontenerów, monitorowania stanu, alokacji zasobów i zależności usług.IronPDFdziała w ramach procesu aplikacji.

Charakterystyka wydajności

Czynnik	Gotenberg	IronPDF
Przetwarzanie	Kontener HTTP round-trip dla każdego żądania	W procesie (bez kosztów sieciowych)
Uruchamianie	Inicjalizacja kontenera przy każdym wdrożeniu/skalowaniu	Inicjalizacja silnika raz na czas życia aplikacji
Pamięć	Osobna alokacja kontenera	Wspoldzielona pamięć aplikacji
Kolejne wersje	Koszty sieciowe utrzymują się dla każdego żądania	Minimalne koszty po inicjalizacji

ArchitekturaGotenbergdodaje koszty sieciowe round-trip do każdego żądania, a zimne starty kontenera występują przy każdym wdrożeniu lub wydarzeniu skalowania. Pierwsze renderowanie wIronPDFpowoduje inicjalizację silnika, ale kolejne renderowania działają w procesie z minimalnymi kosztami.

Kiedy zespoły rozważają przejście zGotenbergna IronPDF

Zespoły programistów rozważają przejście zGotenbergnaIronPDFz kilku powodów:

Koszty infrastruktury: Usługa wymaga Dockera, orkiestracji kontenerów (Kubernetes/Docker Compose), odkrywania usług i równoważenia obciążenia. Zespoły poszukujące prostszego wdrożenia uznają, że podejścieIronPDFoparte wyłącznie na NuGet eliminuje te obawy związane z infrastrukturą.

Opóźnienie sieciowe: Każda operacja PDF przez kontener wymaga wywołania HTTP do osobnej usługi, co dodaje koszty sieciowe round-trip dla każdego żądania. Dla aplikacji o dużej ilości żądań, te koszty się sumują. PodejścieIronPDFoparte na przetwarzaniu w tle powoduje znikome obciążenie po inicjalizacji.

Problemy zimnego startu: Uruchomienie kontenera dodaje opóźnienie inicjalizacji dla pierwszych żądań. Nawet kontenery typu warm generują obciążenie sieciowe. Każde ponowne uruchomienie podu, zdarzenie skalowania w górę lub wdrożenie powoduje uruchomienie od zera. InicjalizacjaIronPDFma miejsce raz na czas życia aplikacji.

Złożoność operacyjna: Wymaga zarządzania zdrowiem kontenerów, skalowaniem, logowaniem i monitorowaniem jako osobnymi kwestiami. Przekroczenia limitów czasu sieci, niedostępność usług i awarie kontenerów stają się problemami aplikacji.IronPDFużywa standardowej obsługi wyjątków .NET.

API Multipart Form Data: Każde żądanie do usługi wymaga konstruowania ładunków multipart/form-data z parametrami opartymi na stringach—rozwlekłe i bez sprawdzania typów w czasie kompilacji.IronPDFzapewnia właściwości typu C# z obsługą IntelliSense.

Zarządzanie wersjami: Obrazy kontenerów aktualizują się oddzielnie od Twojej aplikacji. Zmiany w API mogą zakłócić integrację. WersjamiIronPDFzarządza się za pośrednictwem NuGet przy użyciu standardowego systemu zarządzania zależnościami .NET.

Mocne strony i kwestie do rozważenia

Atuty Gotenberg

Architektura wielojęzyczna: Współpracuje z każdym językiem, który może wykonywać wywołania HTTP
Niezależność od języka: Niezwiązane z ekosystemem .NET
Licencja MIT: Bezpłatna i open source
Wzorzec mikrousług: Pasuje do architektur kontenerowych

Uwagi dotyczące Gotenberga

Obciążenie infrastruktury: wymagane są Docker, Kubernetes i urządzenia równoważące obciążenie
Opóźnienie sieciowe: Kontener HTTP round-trip dla każdego żądania
Zimne starty: Opóźnienie inicjalizacji kontenera
API oparte na ciągach znaków: brak bezpieczeństwa typów ani funkcji IntelliSense
Debugowanie rozproszone: Wymaga śledzenia rozproszonego
Monitorowanie stanu: Dodatkowe punkty końcowe do zarządzania

Atuty IronPDF

Zero Infrastructure: wyłącznie pakiet NuGet
Wydajność podczas działania: brak opóźnień sieciowych po inicjalizacji
API bezpieczne pod względem typów: właściwości silnie typowane z funkcją IntelliSense
Standardowe debugowanie: Działa standardowy debugger .NET Standard
Kompleksowe zasoby: obszerne samouczki i dokumentacja
Profesjonalne wsparcie: Licencja komercyjna obejmuje wsparcie techniczne

Uwagi dotyczące IronPDF

Specyficzne dla .NET: Zaprojektowane dla ekosystemu .NET
Licencja komercyjna: Wymagana do użytku produkcyjnego

Gotenberg iIronPDFreprezentują zasadniczo różne podejścia do generowania plików PDF w aplikacjach .NET. Architektura mikrousługowa Gotenberga oparta na Dockerze wprowadza zarządzanie kontenerami, opóźnienia sieciowe i złożoność operacyjną. Każda operacja na pliku PDF wymaga komunikacji HTTP, co wiąże się z odpowiednimi trybami awarii i obciążeniami związanymi z zimnym startem.

IronPDF zapewnia takie samo renderowanie oparte na Chromium jak biblioteka działająca w tle. Pakiet NuGet eliminuje konieczność stosowania kontenerów Docker, wywołań sieciowych i zarządzania infrastrukturą. Interfejsy API w języku C# zastępują wieloczęściowe dane formularzy oparte na ciągach znaków. .NET Standard zastępuje kody statusu HTTP i tryby awarii sieci.

W miarę jak organizacje planują wdrożenie .NET 10, C# 14 oraz tworzenie aplikacji do 2026 r., wybór między obciążeniem infrastruktury mikrousług a prostotą bibliotek wbudowanych ma znaczący wpływ na złożoność wdrożenia i eksploatacji. Zespoły, które chcą zmniejszyć obciążenie infrastruktury przy zachowaniu wierności renderowania HTML/CSS/JavaScript, przekonają się, żeIronPDFskutecznie spełnia te wymagania.

Zacznij testować IronPDF, korzystając z bezpłatnej wersji próbnej, i zapoznaj się z obszerną dokumentacją, aby ocenić, czy rozwiązanie to spełnia Twoje konkretne wymagania.

Zwróć uwagęGotenberg jest zarejestrowanym znakiem towarowym jego właściciela. Ta strona nie jest powiązana, wspierana, ani sponsorowana przez Gotenberg. Wszystkie nazwy produktów, loga i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

Zwyciestwo klienta:

Podkreslaj programiste:

Webinary:

Iron Suite for .NET

Gotenberg vs IronPDF: Przewodnik po porównaniu technicznym

Zrozumienie Gotenberga

Zrozumienie IronPDF

Porownanie architektury i infrastruktury

Porównanie kodu: typowe operacje na plikach PDF

Podstawowa konwersja HTML do PDF

Konwersja adresów URL do formatu PDF

Niestandardowy rozmiar strony i marginesy

Przewodnik po mapowaniu API

Mapowanie punktu koncowego do metody

Mapowanie parametru formularza do RenderingOptions

Porownanie infrastruktury

GotenbergDocker Compose

Konfiguracja IronPDF

Charakterystyka wydajności

Kiedy zespoły rozważają przejście zGotenbergna IronPDF

Mocne strony i kwestie do rozważenia

Atuty Gotenberg

Uwagi dotyczące Gotenberga

Atuty IronPDF

Uwagi dotyczące IronPDF

Na tej stronie

Zespol wsparcia Iron

Iron Suite for .NET

Gotenberg vs IronPDF: Przewodnik po porównaniu technicznym

Zrozumienie Gotenberga

Zrozumienie IronPDF

Porownanie architektury i infrastruktury

Porównanie kodu: typowe operacje na plikach PDF

Podstawowa konwersja HTML do PDF

Konwersja adresów URL do formatu PDF

Niestandardowy rozmiar strony i marginesy

Przewodnik po mapowaniu API

Mapowanie punktu koncowego do metody

Mapowanie parametru formularza do RenderingOptions

Porownanie infrastruktury

GotenbergDocker Compose

Konfiguracja IronPDF

Charakterystyka wydajności

Kiedy zespoły rozważają przejście zGotenbergna IronPDF

Mocne strony i kwestie do rozważenia

Atuty Gotenberg

Uwagi dotyczące Gotenberga

Atuty IronPDF

Uwagi dotyczące IronPDF

Na tej stronie

Następny krok: Rozpocznij darmową 30-dniową wersję próbną

Want to deploy IronSuite to a live project for FREE?

What’s included?

Zespol wsparcia Iron