COMPARAISON

Gotenberg vs IronPDF : Guide de comparaison technique

Publié:

Lorsque les développeurs .NET évaluent les solutions de génération de PDF, Gotenbergse distingue comme un microservice basé sur Docker qui convertit le HTML en PDF via des appels d'API REST. Bien qu'adaptable à diverses architectures, Gotenbergintroduit une surcharge d'infrastructure notable : conteneurs Docker, latence réseau et complexité opérationnelle.IronPDFpropose une alternative : un package NuGet intégré offrant le même rendu basé sur Chromium sans conteneurs, appels réseau ni gestion d'infrastructure.

Cette comparaison examine les deux solutions selon des dimensions techniques pertinentes afin d'aider les développeurs et les architectes professionnels à prendre des décisions éclairées concernant leurs besoins en matière de PDF .NET.

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 de terminaison tels que POST /forms/chromium/convert/htmlpour la conversion de HTML en PDF et POST /forms/chromium/convert/urlpour la conversion d'URL en PDF. La configuration est transmise via multipart/form-data avec des paramètres basés sur des chaînes 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 (latence de 10-100 ms+)
  • Gestion du démarrage à froid des conteneurs (2 à 5 secondes pour les premières demandes)
  • 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 classe de rendu principale avec des méthodes telles que RenderHtmlAsPdf() et RenderUrlAsPdf(). La configuration utilise des propriétés C# typées sur RenderingOptions, notamment PaperSize, MarginTop, MarginBottom (en millimètres). Les documents sont enregistrés avec SaveAs() ou accessibles en tant que BinaryData.

La bibliothèque ne nécessite que :

  • Installation du paquet 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 10-100ms+ (aller-retour sur le réseau) temps de latence < 1ms
Départ à froid 2-5 secondes (démarrage du conteneur) 1-2 secondes (premier rendu uniquement)
Infrastructure Docker, Kubernetes, équilibreurs de charge Aucune exigence
Dépendance du réseau Les exigences sont les suivantes Aucun
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 Conteneur séparé (512MB-2GB) 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.

Göteborg :

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

Gotenberg nécessite la création d'un HttpClient, la construction d'un MultipartFormDataContent, l'ajout du HTML en tant que fichier joint avec un nom de fichier spécifique (index.html), la réalisation d'un POST HTTP asynchrone vers le point de terminaison du service Gotenberg, la lecture des octets de la réponse et l'écriture 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 enregistre 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.

Göteborg :

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

Gotenberg utilise le point de terminaison /forms/chromium/convert/url avec l'URL transmise en tant que données de formulaire.IronPDFappelle RenderUrlAsPdf() directement avec la chaîne d'URL - un appel de méthode unique 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.

Göteborg :

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

Gotenberg utilise des paramètres à base de chaînes ("8.5", "11", "0.5") ajoutés aux données de formulaires multipartites. Les dimensions du papier sont exprimées en pouces. Chaque paramètre est un appel Add() distinct sans vérification de type ni prise en charge IntelliSense.

IronPDF utilise des propriétés typées sur RenderingOptions. PaperSize accepte un 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
largeur du papier (pouces) RenderingOptions.SetCustomPaperSizeInInches() Méthode d'utilisation pour les traductions personnalisées
hauteur du papier (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
paysage RenderingOptions.PaperOrientation Landscape enum
scale Options de rendu.Zoom Pourcentage (100 = 1,0)
waitDelay RenderingOptions.RenderDelay Convertir en millisecondes
Type de média émulé RenderingOptions.CssMediaType Écran ou Imprimer

Notez la conversion des unités : Gotenbergutilise les pouces pour les marges (par exemple, "0,5" = 0,5 pouces = 12,7 mm), tandis qu'IronPdf utilise les millimètres.

Comparaison des infrastructures

GotenbergDocker 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
YAML

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

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

Opération Gotenberg(conteneur chaud) Gotenberg(Démarrage à froid) IronPDF(premier rendu) IronPDF(suite)
HTML simple 150-300ms 2 à 5 secondes 1-2 secondes 50-150ms
HTML complexe 500-1500ms 3-7 secondes 1.5-3 secondes 200-800ms
Rendu d'URL 1-5 secondes 3-10 secondes 1-5 secondes 500ms-3s
Fusion PDF 200-500ms 2 à 5 secondes 100-300ms 100-300ms

L'aller-retour sur le réseau de Gotenbergajoute 10 à 100 ms+ par requête. Les démarrages à froid des conteneurs ajoutent 2 à 5 secondes. Le premier rendu d'IronPDF entraîne l'initialisation de Chromium (1 à 2 secondes), mais les rendus suivants ont une surcharge minimale.

Quand les équipes envisagent de passer de Gotenbergà IronPDF

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

Infrastructure requise : Gotenbergnécessite Docker, l'orchestration de conteneurs (Kubernetes/Docker Compose), la découverte de services et l'é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 de Gotenbergnécessite un appel HTTP à un service distinct, ce qui ajoute entre 10 et 100 ms par requête. Pour les applications à fort volume de données, cette latence 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 peut ajouter 2 à 5 secondes aux premières requêtes. 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. Le démarrage à froid d'IronPDF se produit une fois par durée de vie de l'application.

Complexité opérationnelle : Gotenbergexige de gérer l'état, la mise à l'échelle, la journalisation et la surveillance des conteneurs comme des problématiques distinctes. Les pannes de réseau, l'indisponibilité des services et les pannes de conteneurs deviennent des préoccupations pour les applications.IronPDFutilise la gestion standard des exceptions .NET.

API Multipart Form Data : chaque requête Gotenbergnécessite la construction de charges utiles multipart/form-data avec des paramètres de type chaîne de caractères — verbeux et sans vérification de type à la compilation.IronPDFfournit des propriétés C# typées avec prise en charge IntelliSense.

Gestion des versions : les images de Gotenbergsont mises à 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 polyglotte : Fonctionne avec tout langage capable d'effectuer des requêtes HTTP
  • Indépendant du langage : non lié à l'écosystème .NET
  • Licence MIT : Source libre et open source
  • Modèle de microservices : Adapté aux architectures conteneurisées

Considérations de Gotenberg

  • Infrastructure requise : Docker, Kubernetes et équilibreurs de charge nécessaires
  • Latence réseau : 10 à 100 ms+ par requête
  • Démarrages à froid : initialisation du conteneur en 2 à 5 secondes
  • API basée sur les chaînes de caractères : aucune sécurité de type ni IntelliSense
  • Débogage distribué : nécessite un traçage distribué
  • Surveillance de la santé : Points de terminaison supplémentaires à gérer

Les points forts d'IronPDF

  • Infrastructure nulle : package NuGet uniquement
  • Performances en cours de traitement : aucune latence réseau après l'initialisation
  • API à typage fort : propriétés fortement typées avec IntelliSense
  • Débogage standard : le débogueur .NET normal fonctionne
  • Ressources complètes : tutoriels et documentation détaillés
  • Assistance professionnelle : La licence commerciale inclut l'assistance

Considérations relatives à IronPDF

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

Gotenberg etIronPDFrepré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 enIronPDFune réponse efficace à ces exigences.

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