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

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

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.

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

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.

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

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 Overhead: 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 du réseau: Chaque opération GotenbergPDF nécessite un appel HTTP à un service distinct, ce qui ajoute 10 à 100 ms+ par requête. Pour les applications à volume élevé, ces frais généraux s'accumulent. L'approche en cours de processus d'IronPDF a des frais généraux négligeables après l'initialisation.

Cold Start Issues: Le démarrage d'un 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 que la gestion de la santé des conteneurs, la mise à l'échelle, la journalisation et la surveillance soient 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.IronPDFutilise la gestion standard des exceptions .NET.

Multipart Form Data API: Chaque requête Gotenbergnécessite la construction de charges utiles multipart/form-data avec des paramètres basés sur des chaînes de caractères - en clair et sans vérification de type au moment de 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 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 du réseau: 10-100ms+ par requête
  • Démarrage à froid: 2-5 secondes 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 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.