Iron Suite for .NET

10 bibliothèques .NET. Une suite de documents complète.

Découvrez Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

COMPARAISON

BitMiracle Docotic PDF vs IronPDF : Guide de comparaison technique

Curtis Chau

Updated: 28 juin 2026

Lorsque les développeurs .NET évaluent les solutions de génération de PDF, Gotenbergse distingue en tant que microservice basé sur Docker qui convertit HTML en PDF par le biais d'appels API REST. Bien qu'adaptable à diverses architectures, Gotenbergintroduit des frais généraux d'infrastructure notables - conteneurs Stocker, latence du réseau et complexité opérationnelle.IronPDF propose une alternative : un package NuGet en cours de traitement fournissant le même rendu basé sur Chromium sans conteneurs, appels réseau ou gestion de l'infrastructure.

Cette comparaison examine les deux solutions à travers des dimensions techniquement pertinentes afin d'aider les développeurs professionnels et les architectes à prendre des décisions éclairées pour leurs besoins en .NET PDF.

Comprendre Gotenberg

Gotenberg est une architecture de microservices basée sur Docker pour la génération de PDF. Il fonctionne comme un conteneur séparé qui expose les points d'extrémité de l'API REST pour la conversion de HTML, d'URL et d'autres formats en PDF. Chaque opération PDF nécessite un appel HTTP au service Gotenberg.

Gotenberg utilise des points d'extrémité comme POST /forms/chromium/convert/html pour la conversion de HTML en PDF et POST /forms/chromium/convert/url pour la conversion de l'URL en PDF. La configuration est transmise via multipart/form-data avec des paramètres basés sur des chaînes de caractères comme paperWidth, paperHeight, marginTop, et marginBottom (en pouces). Le service nécessite le déploiement de Docker, l'orchestration de conteneurs (Kubernetes/Docker Compose) et l'infrastructure réseau.

L'architecture nécessite :

Déploiement et gestion des conteneurs Docker
Communication réseau pour chaque demande de PDF (aller-retour HTTP du conteneur)
Gestion des démarrages à froid du conteneur (délai d'initialisation pour les premières requêtes)
Points d'extrémité du bilan de santé et surveillance des services
Construction multipart/form-data pour chaque requête

Comprendre IronPDF

IronPDF est une bibliothèque native .NET qui s'exécute en cours de processus en tant que package NuGet. Il fournit un rendu HTML basé sur Chromium sans services externes, appels réseau ou infrastructure de conteneur.

IronPDF utilise ChromePdfRenderer comme sa classe de rendu principale avec des méthodes comme RenderHtmlAsPdf() et RenderUrlAsPdf(). La configuration utilise les propriétés C# typées sur RenderingOptions, y compris PaperSize, MarginTop, MarginBottom (en millimètres). Les documents sont sauvegardés avec SaveAs() ou accédés sous forme de BinaryData.

La bibliothèque ne nécessite que :

Installation du package NuGet (dotnet add package IronPdf)
Configuration de la clé de licence
Configuration d'un projet .NET standard

Comparaison de l'architecture et de l'infrastructure

La différence fondamentale entre ces solutions réside dans leur architecture de déploiement et d'exécution.

Facteur	Gotenberg	IronPDF
Déploiement	Conteneur Docker + orchestration	Paquet NuGet unique
Architecture	Microservice (API REST)	Bibliothèque en cours
Latence par requête	Aller-retour HTTP du conteneur	En cours (coût minimal)
Départ à froid	Délai d'initialisation du conteneur	Initialisation du moteur (premier rendu uniquement)
Infrastructure	Docker, Kubernetes, équilibreurs de charge	Aucune exigence
Dépendance du réseau	Les exigences sont les suivantes	None
Modes d'échec	Réseau, conteneur, défaillance de service	Exceptions .NET Standard
Style API	REST multipart/form-data	Appels de méthodes C# natifs
Mise à l'échelle	Horizontal (plus de conteneurs)	Vertical (en cours)
Débogage	Traçage distribué	Débogueur standard
Gestion de la mémoire	Allocation d'un conteneur séparé	Mémoire d'application partagée
Contrôle de la version	Balises de l'image du conteneur	Versions des paquets NuGet
Contrôles de santé	Points d'extrémité HTTP requis	Pas nécessaire (en cours)
Complexité CI/CD	Constructions de conteneurs, poussées de registres	Construction .NET Standard

L'approche de Gotenberg, basée sur Docker, nécessite le déploiement de conteneurs, la surveillance de la santé et la gestion de l'infrastructure réseau.IronPDF élimine entièrement cette couche d'infrastructure en s'exécutant en cours de processus.

Code Comparaison : Opérations PDF courantes

Conversion basique de HTML en PDF

L'opération la plus fondamentale démontre clairement la différence architecturale.

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
    Sub Main()
        MainAsync().GetAwaiter().GetResult()
    End Sub

    Private Async Function MainAsync() 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

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

Module GotenbergExample
    Sub Main()
        MainAsync().GetAwaiter().GetResult()
    End Sub

    Private Async Function MainAsync() 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

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

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf

Module IronPdfExample
    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 Module

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf

Module IronPdfExample
    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 Module

Le service nécessite la création d'un HttpClient, la construction de MultipartFormDataContent, l'ajout de l'HTML en tant que pièce jointe de fichier avec un nom spécifique (index.html), faire un POST HTTP asynchrone vers le point d'extrémité, lire les octets de réponse et écrire sur le disque. Chaque requête passe par le réseau, avec le temps de latence et les modes de défaillance qui y sont associés.

IronPDF crée un ChromePdfRenderer, appelle RenderHtmlAsPdf() avec la chaîne HTML, et sauvegarde avec SaveAs(). L'opération est synchrone, en cours de traitement, et utilise des méthodes typées plutôt que des données de formulaire basées sur des chaînes.

Pour des options de rendu HTML avancées, explorez le guide de conversion du HTML en PDF.

Conversion d'URL en PDF

La conversion de pages web en direct au format PDF présente des schémas architecturaux similaires.

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 = "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 = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = 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

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

Module GotenbergUrlToPdf
    Async Function Main() As Task
        Dim gotenbergUrl = "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 = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = 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

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

' NuGet: Install-Package IronPdf
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

' NuGet: Install-Package IronPdf
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

Le conteneur utilise le point d'extrémité /forms/chromium/convert/url avec l'URL transmise sous forme de données de formulaire.IronPDF appelle RenderUrlAsPdf() directement avec la chaîne d'URL—un seul appel de méthode remplaçant l'infrastructure HTTP.

Personnalisation de la taille des pages et des marges

La gestion de la configuration révèle les différences de conception des 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

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

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

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf
Imports IronPdf.Rendering

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

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

        Dim html = "<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 Class

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf
Imports IronPdf.Rendering

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

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

        Dim html = "<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 Class

Cette approche utilise des paramètres basés sur des chaînes de caractères ("8.5", "11", "0.5") ajoutés aux données de formulaire multipart. Les dimensions du papier sont exprimées en pouces. Chaque paramètre est un appel Add() séparé sans vérification de type ou support d'IntelliSense.

IronPDF utilise des propriétés typées sur RenderingOptions. PaperSize accepte une enum (PdfPaperSize.Letter), et les marges sont des valeurs numériques en millimètres. L'API typée permet une vérification à la compilation et une prise en charge de l'IDE.

Pour en savoir plus sur la configuration du rendu, consultez les tutoriels IronPDF.

Référence de mappage d'API

Pour les développeurs qui évaluent la migration vers Gotenbergou qui comparent les capacités, cette correspondance montre les opérations équivalentes :

Mappage de points de terminaison en méthodes

Route de Gotenberg	Équivalent d'IronPDF
`POST /forms/chromium/convert/html`	`ChromePdfRenderer.RenderHtmlAsPdf()`
`POST /forms/chromium/convert/url`	`ChromePdfRenderer.RenderUrlAsPdf()`
`POST /forms/chromium/convert/markdown`	Rendre Markdown en HTML d'abord
`POST /forms/pdfengines/merge`	`PdfDocument.Merge()`
`POST /forms/pdfengines/metadata/read`	`pdf.MetaData`
`POST /forms/pdfengines/metadata/write`	`pdf.MetaData.Author = "..."`
`GET /health`	N/A

Mappage des paramètres de formulaire aux options de rendu

Paramètre Gotenberg	Propriété d'IronPDF	Notes sur la conversion
`paperWidth` (pouces)	`RenderingOptions.SetCustomPaperSizeInInches()`	Méthode d'utilisation pour les traductions personnalisées
`paperHeight` (pouces)	`RenderingOptions.SetCustomPaperSizeInInches()`	Méthode d'utilisation pour les traductions personnalisées
`marginTop` (pouces)	`RenderingOptions.MarginTop`	Multiplier par 25,4 pour obtenir mm
`marginBottom` (pouces)	`RenderingOptions.MarginBottom`	Multiplier par 25,4 pour obtenir mm
`marginLeft` (pouces)	`RenderingOptions.MarginLeft`	Multiplier par 25,4 pour obtenir mm
`marginRight` (pouces)	`RenderingOptions.MarginRight`	Multiplier par 25,4 pour obtenir mm
`printBackground`	`RenderingOptions.PrintHtmlBackgrounds`	Booléen
`landscape`	`RenderingOptions.PaperOrientation`	`Landscape` enum
`scale`	`RenderingOptions.Zoom`	Pourcentage (100 = 1,0)
`waitDelay`	`RenderingOptions.RenderDelay`	Convertir en millisecondes
`emulatedMediaType`	`RenderingOptions.CssMediaType`	`Screen` ou `Print`

Notez la conversion d'unité : Gotenbergutilise les pouces pour les marges (par exemple, "0.5" = 0.5 pouces = 12.7mm), tandis qu'IronPDF utilise les millimètres.

Comparaison des infrastructures

Gotenbergavec Docker Compose

Gotenberg nécessite une infrastructure de conteneurs :

# 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

Text

Configuration d'IronPDF

IronPDF ne nécessite aucun service supplémentaire :

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

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

Text

La différence d'infrastructure est considérable : Gotenbergnécessite le déploiement de conteneurs, la surveillance de l'état de santé, l'allocation de ressources et les dépendances de services.IronPDFs'exécute en cours de processus avec l'application.

Caractéristiques de performance

Facteur	Gotenberg	IronPDF
Traitement	Aller-retour HTTP du conteneur par demande	En cours (aucun coût réseau)
Démarrage	Initialisation du conteneur à chaque événement de déploiement/mise à l'échelle	Initialisation du moteur une fois par cycle de vie de l'application
Mémoire	Allocation d'un conteneur séparé	Mémoire d'application partagée
Rendu ultérieur	Le coût réseau persiste par demande	Coût minimal après l'initialisation

L'architecture de Gotenbergajoute un coût de réseau aller-retour à chaque demande, et des démarrages à froid des conteneurs se produisent à chaque déploiement ou événement de mise à l'échelle. Le premier rendu d'IronPDF entraîne l'initialisation du moteur, mais les rendus suivants s'exécutent en cours avec un coût minimal.

Quand les équipes envisagent de passer de Gotenbergà IronPDF

Les équipes de développement évaluent la transition de Gotenbergà IronPDF pour plusieurs raisons :

Surcharge d'infrastructure : Le service nécessite Docker, orchestration de conteneurs (Kubernetes/Docker Compose), découverte de services, et équilibrage de charge. Les équipes à la recherche d'un déploiement plus simple constatent que l'approche d'IronPDF basée uniquement sur NuGet élimine ces problèmes d'infrastructure.

Latence réseau : Chaque opération PDF via le conteneur nécessite un appel HTTP à un service séparé, ajoutant un coût de réseau aller-retour par demande. Pour les applications à haut volume, ce coût s'accumule. L'approche en cours de processus d'IronPDF a des frais généraux négligeables après l'initialisation.

Problèmes de démarrage à froid : Le démarrage du conteneur ajoute un délai d'initialisation aux premières demandes. Même les conteneurs chauds ont une surcharge de réseau. Chaque redémarrage de pod, événement de mise à l'échelle ou déploiement déclenche des démarrages à froid. L'initialisation d'IronPDF se produit une fois par cycle de vie de l'application.

Complexité opérationnelle : Cela nécessite de gérer la santé des conteneurs, l'évolutivité, la journalisation et la surveillance comme des préoccupations distinctes. Les pannes de réseau, l'indisponibilité des services et les pannes de conteneurs deviennent des préoccupations pour les applications.IronPDF utilise la gestion standard des exceptions .NET.

API de données de formulaire multipart : Chaque demande au service nécessite la construction de charges multipart/form-data avec des paramètres sous forme de chaîne — verbeux et sans vérification de type à la compilation.IronPDF fournit des propriétés C# typées avec prise en charge IntelliSense.

Gestion des versions : Les images de conteneur se mettent à jour séparément de votre application. Les modifications apportées à l'API peuvent rompre les intégrations. Les versions d'IronPDF sont gérées via NuGet avec la gestion standard des dépendances .NET.

Forces et considérations

Les points forts de Gotenberg

Architecture Polyglot : Fonctionne avec tous les langages qui peuvent faire des appels HTTP
Language Agnostic: Non lié à l'écosystème .NET
Licence MIT: Libre et gratuite
Microservices Pattern: Convient aux architectures conteneurisées

Considérations de Gotenberg

Frais généraux d'infrastructure: Docker, Kubernetes, équilibreurs de charge requis
Latence réseau : Aller-retour HTTP du conteneur par demande
Démarrages à froid : Délai d'initialisation du conteneur
API basée sur des chaînes de caractères : Pas de sécurité de type ni d'IntelliSense
Débogage distribué: Nécessite un traçage distribué
Surveillance de la santé: Points d'extrémité supplémentaires à gérer

Les points forts d'IronPDF

Infrastructure zéro: Paquet NuGet uniquement
Performance en cours de processus: Pas de latence réseau après l'initialisation
Type-Safe API: Propriétés à typage fort avec IntelliSense
Débogage standard : Le débogueur .NET normal fonctionne
Ressources complètes : Des tutoriels et documentation très complets
Support professionnel : La licence commerciale inclut le support

Considérations relatives à IronPDF

Spécifique à .NET : Conçu pour l'écosystème .NET
Licence commerciale: Requise pour une utilisation en production

Gotenberg et IronPDF représentent des approches fondamentalement différentes de la génération de PDF dans les applications .NET. L'architecture de microservices de Gotenberg, basée sur Docker, introduit la gestion des conteneurs, la latence du réseau et la complexité opérationnelle. Chaque opération PDF nécessite une communication HTTP avec les modes de défaillance associés et les pénalités de démarrage à froid.

IronPDF fournit le même rendu basé sur Chromium en tant que bibliothèque en cours de traitement. Le package NuGet élimine les conteneurs Docker, les appels réseau et la gestion de l'infrastructure. Les API C# typées remplacent les données de formulaires multipartites basées sur des chaînes de caractères. La gestion des exceptions .NET standard remplace les codes d'état HTTP et les modes de défaillance du réseau.

Alors que les organisations planifient .NET 10, C# 14 et le développement d'applications jusqu'en 2026, le choix entre la surcharge de l'infrastructure de microservices et la simplicité de la bibliothèque en cours de processus a un impact significatif sur le déploiement et la complexité opérationnelle. Les équipes cherchant à réduire la charge d'infrastructure tout en maintenant la fidélité du rendu HTML/CSS/JavaScript trouveront en IronPDF une réponse efficace à ces exigences.

Commencez à évaluer IronPDF avec un essai gratuit et explorez la documentation complète pour évaluer l'adéquation à vos besoins spécifiques.

Veuillez noter: Gotenberg est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié à, approuvé par, ou parrainé par Gotenberg. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.