Migrar de Gotenberg a IronPDF: VeriFactu, TicketBAI, LOPDGDD y Crea y Crece para ISVs españoles

El problema de la arquitectura Gotenberg

Gotenberg es una arquitectura de microservicios basada en Docker para la generación de PDF. Aunque potente y flexible, introduce una complejidad significativa para las aplicaciones C#:

1. Gastos generales de infraestructura: requiere Docker, orquestación de contenedores (Kubernetes/Docker Compose), descubrimiento de servicios y equilibrio de carga. Cada despliegue es más complejo.

2. Latencia de red: cada operación de PDF requiere una llamada HTTP a un servicio independiente, lo que añade entre 10 y 100 ms por solicitud. Esta latencia aumenta rápidamente en situaciones de alto volumen.

3. Problemas de inicio en frío: el inicio del contenedor puede agregar entre 2 y 5 segundos a las primeras solicitudes. Cada reinicio de pod, cada evento de escalado y cada despliegue desencadenan arranques en frío.

4. Complejidad operativa: debe administrar la salud, la escalabilidad, el registro y la supervisión del contenedor como preocupaciones separadas de su aplicación principal.

5. Datos de formulario multiparte: cada solicitud requiere la construcción de cargas útiles de datos de formulario/multiparte: detalladas, propensas a errores y tediosas de mantener.

6. Puntos de falla: los tiempos de espera de la red, la falta de disponibilidad del servicio y las fallas de los contenedores pasan a ser su responsabilidad.

7. Gestión de versiones: las imágenes de Gotenberg se actualizan por separado de la aplicación; los cambios en la API pueden romper las integraciones de forma inesperada.

Comparación entre Gotenberg e IronPDF

Para los equipos que planifican la adopción de .NET 10 y C# 14 hasta 2025 y 2026, IronPDF proporciona una base preparada para el futuro con cero dependencias de infraestructura que se integra de forma nativa con los patrones modernos de .NET.

Esfuerzo estimado por función

Cambio de paradigma

El cambio fundamental en esta migración de Gotenberg es de llamadas a la API HTTP con datos de formularios multiparte a llamadas a métodos nativos de C#:

Gotenberg:  HTTP POST multipart/form-data a contenedor Docker
IronPDF:    Llamadas directas a métodos en objetos de C#

Prerrequisitos

1. Versión .NET: IronPDF es compatible con .NET Framework 4.6.2+ y .NET Core 3.1+ / .NET 5/6/7/8/9+
2. Clave de licencia: Obtenga su clave de licencia de IronPDF en IronPDF
3. Planificar la eliminación de la infraestructura: documentar los contenedores de Gotenberg para su desmantelamiento posterior a la migración.

Identifique el uso de Gotenberg

# Find direct HTTP calls to Gotenberg
grep -r "gotenberg\|/forms/chromium\|/forms/libreoffice\|/forms/pdfengines" --include="*.cs" .

# Find GotenbergSharpApiClient usage
grep -r "GotenbergSharpClient\|Gotenberg.Sharp\|ChromiumRequest" --include="*.cs" .

# Find Docker/Kubernetes Gotenberg configuration
grep -r "gotenberg/gotenberg\|gotenberg:" --include="*.yml" --include="*.yaml" .

# Find direct HTTP calls to Gotenberg
grep -r "gotenberg\|/forms/chromium\|/forms/libreoffice\|/forms/pdfengines" --include="*.cs" .

# Find GotenbergSharpApiClient usage
grep -r "GotenbergSharpClient\|Gotenberg.Sharp\|ChromiumRequest" --include="*.cs" .

# Find Docker/Kubernetes Gotenberg configuration
grep -r "gotenberg/gotenberg\|gotenberg:" --include="*.yml" --include="*.yaml" .

Cambios en el paquete NuGet

# Remove Gotenberg client (if using)
dotnet remove package Gotenberg.Sharp.API.Client

# Install IronPDF
dotnet add package IronPdf

# Remove Gotenberg client (if using)
dotnet remove package Gotenberg.Sharp.API.Client

# Install IronPDF
dotnet add package IronPdf

Paso 1: Actualizar la configuración de la licencia

Antes (Gotenberg):

Gotenberg no requiere licencia, pero sí una infraestructura Docker con URL de contenedor.

private readonly string _gotenbergUrl = "http://localhost:3000";

private readonly string _gotenbergUrl = "http://localhost:3000";

Private ReadOnly _gotenbergUrl As String = "http://localhost:3000"

Después (IronPDF):

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

' Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY"

Paso 2: Actualizar las importaciones de espacios de nombres

// Before (Gotenberg)
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;

// Before (Gotenberg)
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;

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

Imports IronPdf
Imports IronPdf.Rendering

Gotenberg Endpoint a IronPDF

Mapeo de parámetros de formulario a RenderingOptions

Ejemplo 1: HTML básico a PDF

Antes (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

Después (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

La diferencia es sustancial: Gotenberg requiere construir un HttpClient, construir un MultipartFormDataContent, realizar un HTTP POST asíncrono a un contenedor Docker en ejecución y manejar la respuesta de la matriz de bytes. IronPDF reduce esto a tres líneas con una llamada al método ChromePdfRenderer, sin sobrecarga de red, sin dependencia de contenedor y sin complejidad asincrónica. Consulte la documentación HTML a PDF para obtener más opciones de conversión.

Generación de facturas VeriFactu con IronPDF

Para los desarrolladores españoles que construyen software de facturación, IronPDF permite generar la representación gráfica completa de la factura — incluyendo la leyenda VERI*FACTU y el QR de la AEAT — desde una plantilla HTML sin necesidad de infraestructura Docker:

// NuGet: Install-Package IronPdf
using IronPdf;

class FacturaVeriFactu
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();

        string html = @"
        <html>
        <body style='font-family: Arial, sans-serif; padding: 20px;'>
            <h1>FACTURA Nº 2024-0001</h1>
            <p>Emisor: Mi Empresa S.L. | NIF: B12345678</p>
            <table border='1' cellpadding='5' style='width:100%; border-collapse:collapse;'>
                <tr><th>Concepto</th><th>Base</th><th>IVA 21%</th><th>Total</th></tr>
                <tr><td>Servicio</td><td>1.000,00 €</td><td>210,00 €</td><td>1.210,00 €</td></tr>
            </table>
            <div style='margin-top:20px; border:2px solid black; padding:8px; font-weight:bold;'>
                VERI*FACTU — Factura verificable en la sede electrónica de la AEAT
            </div>
        </body>
        </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("factura-verifactu.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class FacturaVeriFactu
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();

        string html = @"
        <html>
        <body style='font-family: Arial, sans-serif; padding: 20px;'>
            <h1>FACTURA Nº 2024-0001</h1>
            <p>Emisor: Mi Empresa S.L. | NIF: B12345678</p>
            <table border='1' cellpadding='5' style='width:100%; border-collapse:collapse;'>
                <tr><th>Concepto</th><th>Base</th><th>IVA 21%</th><th>Total</th></tr>
                <tr><td>Servicio</td><td>1.000,00 €</td><td>210,00 €</td><td>1.210,00 €</td></tr>
            </table>
            <div style='margin-top:20px; border:2px solid black; padding:8px; font-weight:bold;'>
                VERI*FACTU — Factura verificable en la sede electrónica de la AEAT
            </div>
        </body>
        </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("factura-verifactu.pdf");
    }
}

Imports IronPdf

Class FacturaVeriFactu
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()

        Dim html As String = "
        <html>
        <body style='font-family: Arial, sans-serif; padding: 20px;'>
            <h1>FACTURA Nº 2024-0001</h1>
            <p>Emisor: Mi Empresa S.L. | NIF: B12345678</p>
            <table border='1' cellpadding='5' style='width:100%; border-collapse:collapse;'>
                <tr><th>Concepto</th><th>Base</th><th>IVA 21%</th><th>Total</th></tr>
                <tr><td>Servicio</td><td>1.000,00 €</td><td>210,00 €</td><td>1.210,00 €</td></tr>
            </table>
            <div style='margin-top:20px; border:2px solid black; padding:8px; font-weight:bold;'>
                VERI*FACTU — Factura verificable en la sede electrónica de la AEAT
            </div>
        </body>
        </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("factura-verifactu.pdf")
    End Sub
End Class

Con Gotenberg, este flujo requeriría construir el multipart, esperar la respuesta HTTP, gestionar errores de red y mantener el contenedor Docker activo. Con IronPDF, la generación es síncrona, en proceso y sin dependencias de infraestructura.

Ejemplo 2: Conversión de URL a PDF

Antes (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

Después (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

El enfoque de Gotenberg requiere un punto final diferente (/forms/chromium/convert/url), la creación de contenido multiparte con la URL como campo de formulario y el manejo de respuestas HTTP asincrónicas. El método RenderUrlAsPdf() de IronPDF acepta la URL directamente y devuelve un objeto PdfDocument sincrónicamente. Más información sobre Conversión de URL a PDF.

Ejemplo 3: Tamaño de papel y márgenes personalizados

Antes (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

Después (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

Gotenberg requiere que se agreguen parámetros basados en cadenas ("8.5", "11", "0.5") a los datos de formularios de varias partes; no hay seguridad de tipos, no hay IntelliSense y es fácil escribirlos mal. IronPDF proporciona propiedades fuertemente tipadas con enumeraciones PdfPaperSize y valores de margen numéricos. Tenga en cuenta que los márgenes de IronPDF están en milímetros (50 mm ≈ 2 pulgadas), mientras que Gotenberg utiliza pulgadas.

Conversiones de unidades

La conversión más importante en esta migración de Gotenberg son las unidades de margen:

// Gotenberg: margins in inches
content.Add(new StringContent("0.5"), "marginTop");    // 0.5 inches
content.Add(new StringContent("1"), "marginBottom");   // 1 inch

// IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7;    // 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4; // 1 inch × 25.4 = 25.4mm

// Gotenberg: margins in inches
content.Add(new StringContent("0.5"), "marginTop");    // 0.5 inches
content.Add(new StringContent("1"), "marginBottom");   // 1 inch

// IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7;    // 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4; // 1 inch × 25.4 = 25.4mm

' Gotenberg: margins in inches
content.Add(New StringContent("0.5"), "marginTop")    ' 0.5 inches
content.Add(New StringContent("1"), "marginBottom")   ' 1 inch

' IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7    ' 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4 ' 1 inch × 25.4 = 25.4mm

Fórmula de conversión: millimeters = inches × 25.4

Síncrono frente a asíncrono

Gotenberg requiere operaciones asíncronas debido a la comunicación HTTP:

// Gotenberg: Forced async due to network calls
var response = await client.PostAsync(gotenbergUrl, content);
var pdfBytes = await response.Content.ReadAsByteArrayAsync();

// IronPDF: Synchronous in-process execution
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// IronPDF: Async wrapper if needed
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

// Gotenberg: Forced async due to network calls
var response = await client.PostAsync(gotenbergUrl, content);
var pdfBytes = await response.Content.ReadAsByteArrayAsync();

// IronPDF: Synchronous in-process execution
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// IronPDF: Async wrapper if needed
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

Imports System.Net.Http

' Gotenberg: Forced async due to network calls
Dim response = Await client.PostAsync(gotenbergUrl, content)
Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

' IronPDF: Synchronous in-process execution
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

' IronPDF: Async wrapper if needed
Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))

Manejo de errores

// Gotenberg: HTTP error handling
try
{
    var response = await client.PostAsync(gotenbergUrl, content);
    response.EnsureSuccessStatusCode();  // What if 500? 503? Timeout?
}
catch (HttpRequestException ex) { /* Network error */ }
catch (TaskCanceledException ex) { /* Timeout */ }

// IronPDF: Standard .NET exceptions
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
}
catch (Exception ex)
{
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}

// Gotenberg: HTTP error handling
try
{
    var response = await client.PostAsync(gotenbergUrl, content);
    response.EnsureSuccessStatusCode();  // What if 500? 503? Timeout?
}
catch (HttpRequestException ex) { /* Network error */ }
catch (TaskCanceledException ex) { /* Timeout */ }

// IronPDF: Standard .NET exceptions
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
}
catch (Exception ex)
{
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}

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

' Gotenberg: HTTP error handling
Try
    Dim response = Await client.PostAsync(gotenbergUrl, content)
    response.EnsureSuccessStatusCode()  ' What if 500? 503? Timeout?
Catch ex As HttpRequestException
    ' Network error
Catch ex As TaskCanceledException
    ' Timeout
End Try

' IronPDF: Standard .NET exceptions
Try
    Dim pdf = renderer.RenderHtmlAsPdf(html)
Catch ex As Exception
    Console.WriteLine($"PDF generation failed: {ex.Message}")
End Try

Eliminación de infraestructuras

Tras la migración, elimine Gotenberg de su infraestructura:

# REMOVE from docker-compose.yml:
# services:
#   gotenberg:
#     image: gotenberg/gotenberg:8
#     ports:
#       - "3000:3000"
#     deploy:
#       resources:
#         limits:
#           memory: 2G

# REMOVE from docker-compose.yml:
# services:
#   gotenberg:
#     image: gotenberg/gotenberg:8
#     ports:
#       - "3000:3000"
#     deploy:
#       resources:
#         limits:
#           memory: 2G

Comparación de latencias

Eliminación de costes de infraestructura

Tema 1: Los patrones HttpClient no son necesarios

Problema: el código todavía usa HttpClient y MultipartFormDataContent.

Solución: reemplazar completamente con ChromePdfRenderer:

// Remove all of this:
// using var client = new HttpClient();
// using var content = new MultipartFormDataContent();
// content.Add(new StringContent(html), "files", "index.html");
// var response = await client.PostAsync(url, content);

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

// Remove all of this:
// using var client = new HttpClient();
// using var content = new MultipartFormDataContent();
// content.Add(new StringContent(html), "files", "index.html");
// var response = await client.PostAsync(url, content);

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

Tema 2: Unidades de margen erróneas

Problema: los archivos PDF tienen márgenes incorrectos después de la migración.

Solución: convertir pulgadas a milímetros:

// Gotenberg used inches: "0.5"
// IronPDF uses millimeters: 0.5 × 25.4 = 12.7
renderer.RenderingOptions.MarginTop = 12.7;

// Gotenberg used inches: "0.5"
// IronPDF uses millimeters: 0.5 × 25.4 = 12.7
renderer.RenderingOptions.MarginTop = 12.7;

Edición 3: Referencias URL de contenedores

Problema: el código contiene http://gotenberg:3000 o URL similares.

Solución: elimine todas las referencias URL del contenedor; IronPDF se ejecuta en proceso:

// Remove:
// private readonly string _gotenbergUrl = "http://gotenberg:3000";

// IronPDF needs no URL - it's in-process
var renderer = new ChromePdfRenderer();

// Remove:
// private readonly string _gotenbergUrl = "http://gotenberg:3000";

// IronPDF needs no URL - it's in-process
var renderer = new ChromePdfRenderer();

' Remove:
' Private ReadOnly _gotenbergUrl As String = "http://gotenberg:3000"

' IronPDF needs no URL - it's in-process
Dim renderer As New ChromePdfRenderer()

Pre-Migración

• Inventariar todas las llamadas HTTP de Gotenberg en el código base
• Documentar la configuración actual de Gotenberg (tiempos de espera, márgenes, tamaños de papel)
• Identificar toda la configuración de Gotenberg de Docker/Kubernetes
• Obtener la clave de licencia de IronPDF
• Planificar el desmantelamiento de infraestructuras

Migración de código

• Instalar el paquete NuGet de IronPDF: dotnet add package IronPdf
• Eliminar paquetes de cliente de Gotenberg
• Reemplazar todas las llamadas HTTP a Gotenberg con llamadas al método IronPDF
• Convertir unidades de margen de pulgadas a milímetros
• Actualización del manejo de errores (errores HTTP → excepciones .NET)
• Agregar inicialización de clave de licencia al inicio
• Para software de facturación español: incorporar leyendas VERI*FACTU y QR de la AEAT en plantillas HTML

Migración de infraestructuras

• Eliminar Gotenberg de Docker Compose / Kubernetes
• Actualizar los pipelines de CI/CD (eliminar las extracciones de imágenes de Gotenberg)
• Eliminar los controles de salud de Gotenberg
• Eliminar la URL de Gotenberg de la configuración

Pruebas

• Prueba de conversión de HTML a PDF
• Prueba de conversión de URL a PDF
• Verificar la precisión del margen y del tamaño
• Prueba de rendimiento bajo carga
• Pruebe el tiempo de calentamiento del primer renderizado
• Para software de facturación español: validar leyenda VERI*FACTU, QR AEAT y conformidad Facturae

Posmigración

• Eliminar implementaciones de contenedores de Gotenberg
• Archivar archivos de configuración de Gotenberg
• Actualización de la documentación
• Supervisar el uso de memoria de la aplicación
• Verificar que no haya conexiones de red huérfanas

Ejemplo: factura VeriFactu con IronPDF in-process (NIF/CIF, formato EUR español)

A diferencia de Gotenberg (que requeriría serializar el HTML en una petición HTTP multipart hacia el contenedor), IronPDF genera la factura directamente en el proceso .NET: