COMPARACIóN

Gotenberg vs IronPDF: Guía de comparación técnica

Publicado:

Cuando los desarrolladores de .NET evalúan las soluciones de generación de PDF, Gotenbergse destaca como un microservicio basado en Docker que convierte HTML a PDF a través de llamadas a la API REST. Si bien se adapta a diversas arquitecturas, Gotenbergpresenta una sobrecarga de infraestructura notable (contenedores Docker, latencia de red y complejidad operativa).IronPDFofrece una alternativa: un paquete NuGet en proceso que proporciona la misma representación basada en Chromium sin contenedores, llamadas de red ni administración de infraestructura.

Esta comparación analiza ambas soluciones en dimensiones técnicamente relevantes para ayudar a los desarrolladores y arquitectos profesionales a tomar decisiones informadas para sus necesidades de PDF .NET.

Entendiendo Gotenberg

Gotenberg es una arquitectura de microservicios basada en Docker para la generación de PDF. Se ejecuta como un contenedor independiente que expone puntos finales de API REST para convertir HTML, URL y otros formatos a PDF. Cada operación PDF requiere una llamada HTTP al servicio Gotenberg.

Gotenberg utiliza puntos finales como POST /forms/chromium/convert/htmlpara la conversión de HTML a PDF y POST /forms/chromium/convert/urlpara la conversión de URL a PDF. La configuración se pasa mediante multipart/form-data con parámetros basados en cadenas como paperWidth, paperHeight, marginTop y marginBottom (en pulgadas). El servicio requiere el despliegue de Docker, la orquestación de contenedores (Kubernetes/Docker Compose) y la infraestructura de red.

La arquitectura requiere:

  • Despliegue y gestión de contenedores Docker
  • Comunicación de red para cada solicitud de PDF (latencia de 10-100 ms+)
  • Gestión de arranque en frío de contenedores (2-5 segundos para las primeras solicitudes)
  • Puntos finales de comprobación de estado y supervisión de servicios
  • Construcción multipart/form-data para cada solicitud

Entendiendo IronPDF

IronPDF es una biblioteca nativa de .NET que se ejecuta en proceso como un paquete NuGet. Proporciona renderizado HTML basado en Chromium sin servicios externos, llamadas de red o infraestructura de contenedores.

IronPDF utiliza ChromePdfRenderer como su principal clase de renderizado con métodos como RenderHtmlAsPdf() y RenderUrlAsPdf(). La configuración utiliza propiedades C# tipificadas en RenderingOptions, como PaperSize, MarginTop, MarginBottom (en milímetros). Los documentos se guardan con SaveAs() o se accede a ellos como BinaryData.

La biblioteca sólo requiere:

  • Instalación del paquete NuGet (dotnet add package IronPdf)
  • Configuración de la clave de licencia
  • Configuración de proyectos .NET Standard

Comparación de arquitecturas e infraestructuras

La diferencia fundamental entre estas soluciones radica en su arquitectura de despliegue y ejecución.

FactorGotenbergIronPDF
DespliegueContenedor Docker + orquestaciónPaquete NuGet único
ArquitecturaMicroservicio (API REST)Biblioteca en proceso
Latencia por solicitud10-100ms+ (ida y vuelta en red)< 1ms de sobrecarga
Inicio en frío2-5 segundos (init del contenedor)1-2 segundos (sólo la primera traducción)
InfraestructuraDocker, Kubernetes, balanceadores de cargaNo es necesario
Dependencia de la redRequeridoNinguno
Modos de falloFallos en redes, contenedores y serviciosExcepciones de .NET Standard
Estilo APIREST multipart/form-dataLlamadas a métodos nativos de C#
EscaladoHorizontal (más contenedores)Vertical (en proceso)
DepuraciónRastreo distribuidoDepurador estándar
Gestión de memoriaContenedor independiente (512 MB-2 GB)Memoria de aplicación compartida
Control de versionesEtiquetas de la imagen del contenedorVersiones de los paquetes NuGet
ComprobacionesPuntos finales HTTP necesariosNo se necesita (en proceso)
CI/CD complejidadCreación de contenedores, inserción de registrosVersión .NET Standard

El enfoque de Gotenbergbasado en Docker requiere el despliegue de contenedores, la supervisión de la salud y la gestión de la infraestructura de red.IronPDFelimina por completo esta capa de infraestructura al ejecutarse en el proceso.

Comparación de códigos: Operaciones comunes en PDF

Conversión básica de HTML a PDF

La operación más fundamental demuestra claramente la diferencia arquitectónica.

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");
    }
}
$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 requiere crear un HttpClient, construir MultipartFormDataContent, añadir el HTML como un archivo adjunto con un nombre de archivo específico (index.html), hacer un HTTP POST asíncrono al punto final del servicio Gotenberg, leer los bytes de respuesta y escribir en el disco. Todas las solicitudes se realizan a través de la red, con la latencia y los modos de fallo asociados.

IronPDF crea un ChromePdfRenderer, llama a RenderHtmlAsPdf() con la cadena HTML y guarda con SaveAs(). La operación es sincrónica, en proceso, y utiliza métodos tipificados en lugar de datos de formulario basados en cadenas.

Para conocer las opciones avanzadas de conversión de HTML, consulte la Guía de conversión de HTML a PDF.

Conversión de URL a PDF

La conversión de páginas web a PDF muestra patrones arquitectónicos similares.

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");
    }
}
$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 utiliza el punto final /forms/chromium/convert/url con la URL pasada como datos del formulario.IronPDFllama a RenderUrlAsPdf() directamente con la cadena URL: una única llamada a un método que sustituye a la infraestructura HTTP.

Tamaño de página y márgenes personalizados

El manejo de la configuración revela las diferencias de diseño de las 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");
    }
}
$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 utiliza parámetros basados en cadenas ("8.5", "11", "0.5") que se añaden a los datos de formularios multiparte. Las dimensiones del papel están en pulgadas. Cada parámetro es una llamada Add() independiente sin comprobación de tipo ni soporte de IntelliSense.

IronPDF utiliza propiedades tipadas en RenderingOptions. PaperSize acepta un enum (PdfPaperSize.Letter), y los márgenes son valores numéricos en milímetros. La API tipada ofrece comprobación en tiempo de compilación y compatibilidad con IDE.

Obtenga más información sobre la configuración de la renderización en Tutoriales de IronPDF.

Referencia de mapeo de API

Para los desarrolladores que estén evaluando la migración a Gotenbergo comparando capacidades, este mapeo muestra operaciones equivalentes:

Mapeo de punto final a método

Ruta GotenbergEquivalente de IronPDF
POST /forms/chromium/convert/html<código>ChromePdfRenderer.RenderHtmlAsPdf()</código
POST /forms/chromium/convert/url<código>ChromePdfRenderer.RenderUrlAsPdf()</código
POST /forms/chromium/convert/markdownRender Markdown como HTML primero
POST /forms/pdfengines/mergePdfDocument.Merge()
POST /forms/pdfengines/metadata/read<código>pdf.MetaData</código
<código>POST /forms/pdfengines/metadata/write</código<código>pdf.MetaData.Author = "..."</código
COMPRAR /healthN/A

Mapeo de parámetros de formulario a RenderingOptions

Parámetro GotenbergPropiedad de IronPDFNotas de conversión
paperWidth (pulgadas)<código>RenderingOptions.SetCustomPaperSizeInInches()</códigoMétodo de uso personalizado
altura del papel (pulgadas)<código>RenderingOptions.SetCustomPaperSizeInInches()</códigoMétodo de uso personalizado
marginTop (pulgadas)<código>RenderingOptions.MarginTop</códigoMultiplique por 25,4 para mm
margenInferior (pulgadas)<código>RenderingOptions.MarginBottom</códigoMultiplique por 25,4 para mm
margenIzquierdo (pulgadas)<código>RenderingOptions.MarginLeft</códigoMultiplique por 25,4 para mm
margenDerecho (pulgadas)<código>RenderingOptions.MarginRight</códigoMultiplique por 25,4 para mm
<código>printBackground</código<código>RenderingOptions.PrintHtmlBackgrounds</códigoBooleano
paisaje<código>RenderingOptions.PaperOrientation</códigoPaisaje enum
escala<código>RenderingOptions.Zoom</códigoPorcentaje (100 = 1,0)
waitDelay<código>RenderingOptions.RenderDelay</códigoConvertir a milisegundos
<código>emulatedMediaType</código<código>RenderingOptions.CssMediaType</códigoPantalla o Imprimir

Nótese la conversión de unidades: Gotenbergutiliza pulgadas para los márgenes (por ejemplo, "0,5" = 0,5 pulgadas = 12,7 mm), mientras queIronPDFutiliza milímetros.

Comparación de infraestructuras

GotenbergDocker Compose

Gotenberg requiere una infraestructura de contenedores:

# 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

Configuración de IronPDF

IronPDF no requiere servicios adicionales:

#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 diferencia de infraestructura es sustancial: Gotenbergrequiere el despliegue de contenedores, la supervisión de la salud, la asignación de recursos y las dependencias de servicios.IronPDFse ejecuta en proceso con la aplicación.

Características de rendimiento

OperaciónGotenberg(Contenedor caliente)Gotenberg(Arranque en frío)IronPDF(Primera versión)IronPDF(continuación)
HTML sencillo150-300ms2-5 segundos1-2 segundos50-150ms
HTML complejo500-1500ms3-7 segundos1.5-3 segundos200-800ms
Renderización de URL1-5 segundos3-10 segundos1-5 segundos500ms-3s
Fusión de PDF200-500ms2-5 segundos100-300ms100-300ms

El viaje de ida y vuelta por la red de Gotenbergañade entre 10 y 100 ms por solicitud. Los arranques en frío de contenedores añaden 2-5 segundos. La primera renderización deIronPDFrequiere la inicialización de Chromium (1-2 segundos), pero las siguientes tienen una sobrecarga mínima.

Cuándo los equipos consideran pasar de Gotenberga IronPDF

Los equipos de desarrollo evalúan la transición de GotenbergaIronPDFpor varias razones:

Gastos generales de infraestructura: Gotenbergrequiere Docker, orquestación de contenedores (Kubernetes/Docker Compose), descubrimiento de servicios y equilibrio de carga. Los equipos que buscan una implantación más sencilla descubren que el enfoque deIronPDFbasado únicamente en NuGet elimina estos problemas de infraestructura.

Latencia de red: Cada operación de GotenbergPDF requiere una llamada HTTP a un servicio independiente, lo que añade entre 10 y 100 ms por solicitud. En aplicaciones de alto volumen, esta sobrecarga se acumula. El enfoque en proceso deIronPDFtiene una sobrecarga insignificante después de la inicialización.

Problemas de inicio en frío: el inicio del contenedor puede agregar entre 2 y 5 segundos a las primeras solicitudes. Incluso los contenedores calientes tienen sobrecarga de red. Cada reinicio de pod, evento de escalado o despliegue desencadena arranques en frío. El arranque en frío deIronPDFse produce una vez durante la vida útil de la aplicación.

Complejidad operativa: Gotenbergrequiere gestionar la salud de los contenedores, la escala, el registro y la supervisión como preocupaciones separadas. Los tiempos de espera de la red, la indisponibilidad del servicio y las caídas del contenedor se convierten en preocupaciones de la aplicación.IronPDFutiliza la gestión de excepciones estándar de .NET.

API de datos de formularios multiparte: cada solicitud de Gotenbergrequiere la construcción de cargas útiles multiparte/datos de formulario con parámetros basados en cadenas (detallados y sin verificación de tipos en tiempo de compilación).IronPDFproporciona propiedades tipificadas de C# compatibles con IntelliSense.

Gestión de versiones: las imágenes de Gotenbergse actualizan por separado de la aplicación. Los cambios en la API pueden romper las integraciones. Las versiones deIronPDFse gestionan a través de NuGet con la gestión de dependencias estándar de .NET.

Fuerzas y consideraciones

Puntos fuertes de Gotenberg

  • Arquitectura políglota: funciona con cualquier lenguaje que pueda realizar llamadas HTTP
  • Agnóstico del lenguaje: no vinculado al ecosistema .NET
  • Licencia MIT: Libre y de código abierto
  • Patrón de microservicios: se adapta a arquitecturas en contenedores

Consideraciones de Gotenberg

  • Infraestructura adicional: Docker, Kubernetes, balanceadores de carga requeridos
  • Latencia de red: 10-100 ms+ por solicitud
  • Arranques en frío: inicialización del contenedor de 2 a 5 segundos
  • API basada en cadenas: sin seguridad de tipos ni IntelliSense
  • Depuración distribuida: requiere seguimiento distribuido
  • Monitoreo de salud: puntos finales adicionales para administrar

Puntos fuertes de IronPDF

  • Infraestructura cero: solo paquete NuGet
  • Rendimiento en proceso: sin latencia de red después de la inicialización
  • API de tipo seguro: Propiedades fuertemente tipadas con IntelliSense
  • Depuración estándar: el depurador .NET normal funciona
  • Recursos completos: tutoriales y documentación extensos
  • Soporte profesional: La licencia comercial incluye soporte

Consideraciones sobre IronPDF

  • Específico de .NET: diseñado para el ecosistema .NET
  • Licencia comercial: requerida para uso en producción

Gotenberg eIronPDFrepresentan enfoques fundamentalmente diferentes para la generación de PDF en aplicaciones .NET. La arquitectura de microservicios basada en Docker de Gotenbergintroduce la gestión de contenedores, la latencia de la red y la complejidad operativa. Cada operación PDF requiere comunicación HTTP con modos de fallo asociados y penalizaciones por arranque en frío.

IronPDF proporciona el mismo renderizado basado en Chromium como biblioteca en proceso. El paquete NuGet elimina los contenedores Docker, las llamadas de red y la gestión de infraestructuras. Las API tipificadas de C# sustituyen a los datos de formulario multiparte basados en cadenas. El manejo de excepciones estándar de .NET sustituye a los códigos de estado HTTP y a los modos de fallo de red.

A medida que las organizaciones planifican .NET 10, C# 14 y el desarrollo de aplicaciones hasta 2026, la elección entre la sobrecarga de la infraestructura de microservicios y la simplicidad de las bibliotecas en proceso afecta significativamente a la implantación y la complejidad operativa. Los equipos que busquen reducir la carga de la infraestructura al tiempo que mantienen la fidelidad de la renderización HTML/CSS/JavaScript encontrarán queIronPDFaborda estos requisitos con eficacia.

Comience a evaluarIronPDFcon una prueba gratuita y explore la documentación exhaustiva para evaluar si se adapta a sus requisitos específicos.