Cómo convertir Razor a PDF en Blazor Server usando C#

Los desafíos del Container-API

Kaizen.io HTML-to-PDF es un contenedor Docker con una API v1.x deliberadamente pequeña, y la historia de integración de C# es lo que tú mismo construyes sobre HttpClient. Esa forma tiene límites reales en producción:

1. Contenedor para operar: Ejecutas, monitoreas y actualizas kaizenio.azurecr.io/html-to-pdf:latest en algún lugar accesible desde tu aplicación: Docker local, sidecar o un host separado.

2. Sin SDK for .NET: Cada llamada en C# se hace manualmente HttpClient POST + JSON. Sin IntelliSense, sin verificaciones en tiempo de compilación sobre la forma de la solicitud.

3. Superficie de la API v1.x muy pequeña: El cuerpo JSON documentado acepta solo un campo html. URL-to-PDF, hojas de estilo personalizadas, encabezados/pies de página, tamaño de página, orientación y márgenes están listados como elementos en el mapa de ruta en lugar de características entregables: cualquier cosa más allá de renderear una cadena de HTML debe expresarse dentro del HTML mismo, típicamente a través de @page CSS y divs posicionados absolutamente.

4. Sin soporte de números de página: La API no tiene marcadores `{page} / {total}, por lo que no se pueden producir pies de página del tipo "Página X de Y" del lado del servidor.

5. Viaje de ida y vuelta HTTP por cada PDF: Incluso cuando el contenedor se ejecuta en localhost, cada PDF conlleva una serialización JSON y un salto de socket.

6. Marca de agua en la versión gratuita: Sin la variable de entorno KAIZEN_PDF_LICENSE establecida en el contenedor, la salida tiene marca de agua.

Comparación Kaizen.io vs IronPDF

Para los equipos que estandarizan en .NET moderno, IronPDF elimina el contenedor sidecar y el salto HTTP de la ruta de solicitud al tiempo que expone una superficie de configuración con tipos definidos.

Esfuerzo estimado por característica

Cambio de paradigma

El cambio fundamental es de llamadas HTTP fuera de proceso a un contenedor Docker a renderizado en proceso:

Kaizen.io:  HttpClient.PostAsync("http://.../html-to-pdf", { html }) → byte[]
IronPDF:    ChromePdfRenderer → RenderHtmlAsPdf(html) → PdfDocument

Requisitos previos

1. .NET Environment: .NET Framework 4.6.2+ or .NET Core 3.1+ / .NET 5+
2. Acceso a NuGet: Habilidad para instalar paquetes NuGet
3. Licencia de IronPDF: Obtén tu clave de licencia desde ironpdf.com

Cambios en el paquete

No hay paquete NuGet de Kaizen para eliminar, ya que Kaizen se distribuye únicamente como una imagen Docker. Detén el contenedor y añade el paquete IronPDF:

# Stop and remove the running Kaizen container (if any)
docker stop kaizen-pdf
docker rm kaizen-pdf

# Install IronPDF
dotnet add package IronPdf

# Stop and remove the running Kaizen container (if any)
docker stop kaizen-pdf
docker rm kaizen-pdf

# Install IronPDF
dotnet add package IronPdf

Configuración de la licencia

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Identificar el uso de Kaizen.io

Debido a que Kaizen no tiene un SDK, las llamadas a él parecen POSTs genéricos HttpClient. Busca el punto final, el nombre de la imagen y la variable de entorno de la licencia en lugar de un espacio de nombres:

grep -r "html-to-pdf\|KAIZEN_PDF_LICENSE\|kaizenio.azurecr.io\|localhost:8080" \
  --include="*.cs" --include="*.json" --include="*.yml" .

grep -r "html-to-pdf\|KAIZEN_PDF_LICENSE\|kaizenio.azurecr.io\|localhost:8080" \
  --include="*.cs" --include="*.json" --include="*.yml" .

Mapeo de conceptos

No hay una clase .NET de Kaizen para mapear; solo la forma de la solicitud JSON y las convenciones que construiste a su alrededor.

Mapeo de marcadores de posición

Kaizen v1.x no tiene marcadores de posición del lado del servidor. Si anteriormente sustituiste manualmente cadenas en el HTML antes de hacer POST, cambia a los marcadores de posición en tiempo de renderizado de IronPDF:

Ejemplo 1: HTML básico a PDF

Antes (Kaizen.io — POST JSON al contenedor):

// Container must be running:
//   docker run -d -p 8080:8080 -e KAIZEN_PDF_LICENSE=... \
//     kaizenio.azurecr.io/html-to-pdf:latest
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html = "<html><body><h1>Hello World</h1></body></html>" });
        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);
        response.EnsureSuccessStatusCode();
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

// Container must be running:
//   docker run -d -p 8080:8080 -e KAIZEN_PDF_LICENSE=... \
//     kaizenio.azurecr.io/html-to-pdf:latest
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html = "<html><body><h1>Hello World</h1></body></html>" });
        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);
        response.EnsureSuccessStatusCode();
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

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

Module Program
    Async Function Main() As Task
        Using http As New HttpClient()
            Dim payload = JsonSerializer.Serialize(New With {.html = "<html><body><h1>Hello World</h1></body></html>"})
            Dim content As New StringContent(payload, Encoding.UTF8, "application/json")
            Dim response = Await http.PostAsync("http://localhost:8080/html-to-pdf", content)
            response.EnsureSuccessStatusCode()
            Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
            File.WriteAllBytes("output.pdf", pdfBytes)
        End Using
    End Function
End Module

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

El enfoque de Kaizen.io serializa JSON, lo envía al punto final REST del contenedor, verifica el código de estado, lee la respuesta como bytes y escribe esos bytes en el disco. El ChromePdfRenderer de IronPDF se ejecuta en proceso — RenderHtmlAsPdf() devuelve un PdfDocument con un método SaveAs(), por lo que el viaje de ida y vuelta y la manipulación manual de bytes desaparecen. Consulta la documentación de HTML a PDF para opciones de renderizado adicionales.

Ejemplo 2: Archivo HTML a PDF con configuración de página

Kaizen v1.x no tiene punto final de archivo ni campos de diseño de página: lees el archivo tú mismo e insertas el tamaño/orientación de la página en @page CSS.

Before (Kaizen.io):

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var body = File.ReadAllText("input.html");
        var html = "<style>@page { size: A4 portrait; }</style>" + body;

        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("document.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var body = File.ReadAllText("input.html");
        var html = "<style>@page { size: A4 portrait; }</style>" + body;

        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("document.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

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

Module Program
    Async Function Main() As Task
        Dim body = File.ReadAllText("input.html")
        Dim html = "<style>@page { size: A4 portrait; }</style>" & body

        Using http As New HttpClient()
            Dim payload = JsonSerializer.Serialize(New With {Key .html = html})
            Dim response = Await http.PostAsync(
                "http://localhost:8080/html-to-pdf",
                New StringContent(payload, Encoding.UTF8, "application/json"))
            response.EnsureSuccessStatusCode()
            File.WriteAllBytes("document.pdf", Await response.Content.ReadAsByteArrayAsync())
        End Using
    End Function
End Module

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("document.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("document.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("document.pdf")
    End Sub
End Class

RenderHtmlFileAsPdf() lee el archivo directamente, y el tamaño y la orientación de la página se mueven del CSS en línea @page a las propiedades RenderingOptions.

Ejemplo 3: URL a PDF con encabezados y pies de página

Kaizen v1.x no tiene ConvertUrl, ni campos de encabezado/pie de página, ni marcadores de posición de números de página. La solución alternativa es obtener la página tú mismo y envolverla con @page CSS y divs de posición fija para simular el encabezado/pie de página: sin forma de renderizar números de página.

Before (Kaizen.io):

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var page = await http.GetStringAsync("https://example.com");
        var html = $@"<!doctype html><html><head><style>
            @page {{margin: 20mm;}}
            .h {{position: fixed; top: -15mm; left: 0; right: 0; text-align: center;}}
            .f {{position: fixed; bottom: -15mm; left: 0; right: 0; text-align: center;}}
        </style></head><body>
            <div class='h'>Company Header</div>
            <div class='f'>Footer (page numbers unsupported in Kaizen v1.x)</div>
            {page}
        </body></html>";

        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("webpage.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var page = await http.GetStringAsync("https://example.com");
        var html = $@"<!doctype html><html><head><style>
            @page {{margin: 20mm;}}
            .h {{position: fixed; top: -15mm; left: 0; right: 0; text-align: center;}}
            .f {{position: fixed; bottom: -15mm; left: 0; right: 0; text-align: center;}}
        </style></head><body>
            <div class='h'>Company Header</div>
            <div class='f'>Footer (page numbers unsupported in Kaizen v1.x)</div>
            {page}
        </body></html>";

        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("webpage.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

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

Module Program
    Async Function Main() As Task
        Using http As New HttpClient()
            Dim page As String = Await http.GetStringAsync("https://example.com")
            Dim html As String = $"<!doctype html><html><head><style>
                @page {{margin: 20mm;}}
                .h {{position: fixed; top: -15mm; left: 0; right: 0; text-align: center;}}
                .f {{position: fixed; bottom: -15mm; left: 0; right: 0; text-align: center;}}
            </style></head><body>
                <div class='h'>Company Header</div>
                <div class='f'>Footer (page numbers unsupported in Kaizen v1.x)</div>
                {page}
            </body></html>"

            Dim payload As String = JsonSerializer.Serialize(New With {Key .html = html})
            Dim response As HttpResponseMessage = Await http.PostAsync(
                "http://localhost:8080/html-to-pdf",
                New StringContent(payload, Encoding.UTF8, "application/json"))
            response.EnsureSuccessStatusCode()
            File.WriteAllBytes("webpage.pdf", Await response.Content.ReadAsByteArrayAsync())
        End Using
    End Function
End Module

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.TextHeader.CenterText = "Company Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page} of {total-pages}";
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.TextHeader.CenterText = "Company Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page} of {total-pages}";
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.TextHeader.CenterText = "Company Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page} of {total-pages}"
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

RenderUrlAsPdf() obtiene y renderiza la URL directamente; no hay obtención de página del lado del cliente, y los divs de posición fija falsos se reemplazan con zonas TextHeader / TextFooter. Los números de página se producen mediante los marcadores de posición `{page} y {total-pages}, que Kaizen v1.x no proporciona. Obtén más información sobre la conversión de URL a PDF y encabezados y pies de página.

La licencia vive en el código, no en el contenedor

La licencia de Kaizen se configura a través de la variable de entorno KAIZEN_PDF_LICENSE en el contenedor Docker. La licencia de IronPDF es una propiedad estática establecida una vez al inicio de la aplicación:

// DELETE the Kaizen container env var:
//   docker run ... -e KAIZEN_PDF_LICENSE=... kaizenio.azurecr.io/html-to-pdf

// IronPDF: set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

// DELETE the Kaizen container env var:
//   docker run ... -e KAIZEN_PDF_LICENSE=... kaizenio.azurecr.io/html-to-pdf

// IronPDF: set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

' DELETE the Kaizen container env var:
'   docker run ... -e KAIZEN_PDF_LICENSE=... kaizenio.azurecr.io/html-to-pdf

' IronPDF: set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()

Sintaxis de marcadores de posición

Si anteriormente sustituiste manualmente cadenas en el HTML antes de hacer POST, cambia a los marcadores de posición en tiempo de renderizado de IronPDF:

• `{page} (sin cambios)
• `{total} → {total-pages}
• `{title} → {html-title}
• `{date} → `{date} (sin cambios)

Cambio en el tipo de retorno

Kaizen devuelve bytes sin procesar a través de HTTP. IronPDF devuelve un PdfDocument:

// Kaizen.io returns byte[] via HTTP
byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
File.WriteAllBytes("output.pdf", pdfBytes);

// IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");           // Direct save
byte[] bytes = pdf.BinaryData;      // Or get bytes if needed

// Kaizen.io returns byte[] via HTTP
byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
File.WriteAllBytes("output.pdf", pdfBytes);

// IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");           // Direct save
byte[] bytes = pdf.BinaryData;      // Or get bytes if needed

Imports System.IO

' Kaizen.io returns Byte() via HTTP
Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
File.WriteAllBytes("output.pdf", pdfBytes)

' IronPDF returns PdfDocument
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")           ' Direct save
Dim bytes As Byte() = pdf.BinaryData ' Or get bytes if needed

Eliminar la plomería HTTP

Una vez que el renderizador está en proceso, el código de soporte desaparece:

// DELETE all of:
// - HttpClient lifetime management
// - JSON serialization of { html }
// - response.EnsureSuccessStatusCode() / status-code branches
// - "container unreachable" retry/backoff
// - ReadAsByteArrayAsync()

// Replaced with a single in-process call:
var pdf = renderer.RenderHtmlAsPdf(html);

// DELETE all of:
// - HttpClient lifetime management
// - JSON serialization of { html }
// - response.EnsureSuccessStatusCode() / status-code branches
// - "container unreachable" retry/backoff
// - ReadAsByteArrayAsync()

// Replaced with a single in-process call:
var pdf = renderer.RenderHtmlAsPdf(html);

Problema 1: Clase HtmlToPdfConverter no existe

Problema: No hay una clase HtmlToPdfConverter para intercambiar: Kaizen no tiene ningún SDK for .NET.

Solución: La migración es desde HttpClient POSTs contra el contenedor hacia ChromePdfRenderer:

// Kaizen.io: hand-rolled HTTP
using var http = new HttpClient();
var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);

// IronPDF: in-process renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

// Kaizen.io: hand-rolled HTTP
using var http = new HttpClient();
var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);

// IronPDF: in-process renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

Imports System.Net.Http
Imports IronPdf

' Kaizen.io: hand-rolled HTTP
Using http As New HttpClient()
    Dim response = Await http.PostAsync("http://localhost:8080/html-to-pdf", content)
End Using

' IronPDF: in-process renderer
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

Problema 2: ¿Dónde fue el objeto de opciones?

Problema: Kaizen v1.x no tiene ConversionOptions: el diseño de página era CSS en línea @page, los encabezados/pies de página eran divs de posición fija.

Solución: Mueve esa configuración a RenderingOptions en el renderizador:

// Before: <style>@page { size: A4 portrait; margin: 20mm; }</style>
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;

// Before: <style>@page { size: A4 portrait; margin: 20mm; }</style>
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;

' Before: <style>@page { size: A4 portrait; margin: 20mm; }</style>
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20

Problema 3: Los números de página no se renderizan

Problema: Kaizen v1.x no tiene soporte para marcadores de posición `{page} / {total}, por lo que cualquier pie de página "Página X de Y" antes de la migración estaba ausente o era texto estático.

Solución: Usa los marcadores de posición de encabezado/pie de página de IronPDF:

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}"
};

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}"
};

renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .CenterText = "Page {page} of {total-pages}"
}

Si anteriormente sustituías manualmente {total} en tu propio código antes de hacer POST, elimina esa sustitución — IronPDF resuelve ``{total-pages} en tiempo de renderizado.

Problema 4: Errores de conexión con el contenedor

Problema: Rutas de código que manejan errores de "contenedor inaccesible" / puerto-8080.

Solución: IronPDF se ejecuta en proceso; no hay punto final al que conectarse. Elimina el manejo de errores de conexión.

Problema 5: Primer renderizado lento

Problema: La primera generación de PDF tarda de 1 a 3 segundos.

Solución: IronPDF inicializa Chromium en el primer uso. Calienta al inicio de la aplicación:

// In Program.cs or Startup.cs:
new ChromePdfRenderer().RenderHtmlAsPdf("<html></html>");

// In Program.cs or Startup.cs:
new ChromePdfRenderer().RenderHtmlAsPdf("<html></html>");

' In Program.vb or Startup.vb:
Call New ChromePdfRenderer().RenderHtmlAsPdf("<html></html>")

Pre-migración

• Localiza cada sitio de llamada a Kaizen (busca html-to-pdf, KAIZEN_PDF_LICENSE, kaizenio.azurecr.io, localhost:8080)
• Documenta CSS en línea @page usado para tamaño, orientación, márgenes
• Documenta divs de encabezado/pie de página falsos (posición fija con desplazamientos negativos)
• Lista cualquier sustitución de marcador de posición del lado del cliente (html.Replace("{page}", ...) etc.)
• Nota ciclo de vida del contenedor: pull, run, restart, variable de entorno de licencia
• Obtén clave de licencia de IronPDF

Desmantelamiento del contenedor

• Detén y elimina el contenedor de Kaizen en ejecución (docker stop kaizen-pdf && docker rm kaizen-pdf)
• Elimina los pasos de pull/run de Kaizen de CI/CD
• Elimina KAIZEN_PDF_LICENSE de los secretos/entorno
• Instala el paquete NuGet IronPdf (dotnet add package IronPdf)

Cambios en el código

• Añade configuración de clave de licencia al inicio
• Reemplaza HttpClient POST con ChromePdfRenderer
• Mueve CSS incrustado @page a propiedades RenderingOptions
• Reemplaza POST JSON con RenderHtmlAsPdf() / RenderHtmlFileAsPdf() / RenderUrlAsPdf()
• Reemplaza divs de encabezado/pie de página falsos con TextHeader/Footer o HtmlHeader/Footer
• Actualiza la sintaxis de marcadores de posición ({total} → ``{total-pages}``, ``{title} → {html-title})
• Reemplaza cuerpo HTTP byte[] con pdf.BinaryData
• Usa pdf.SaveAs() en lugar de File.WriteAllBytes()
• Elimina el manejo de errores de accedo al contenedor y el retry/backoff

Testing

• Prueba todos los caminos de generación de PDF
• Verifica el renderizado de encabezados/pies de página y números de página (nueva capacidad)
• Valida márgenes, tamaño de página y orientación
• Prueba operación offline (sin contenedor requerido)

Post-migración

• Desmantela la infraestructura de contenedor Kaizen
• Actualiza variables de entorno / secretos
• Elimina revisiones de salud del contenedor de monitoreo/alerta
• Documenta los nuevos patrones de errores con excepciones tipadas