Como migrar do Kaizen.io para o IronPDF em C#

Os Desafios da API do Contêiner

Kaizen.io HTML-to-PDF é um contêiner Docker com uma API v1.x deliberadamente pequena, e a integração C# é o que você constrói por conta própria em cima do HttpClient. Essa forma tem limites reais em produção:

1. Contêiner para Operar: Você executa, monitora e atualiza kaizenio.azurecr.io/html-to-pdf:latest em algum lugar acessível do seu aplicativo — Docker local, sidecar ou um host separado.

2. Sem SDK .NET: Cada chamada C# é feita manualmente HttpClient POST + JSON. Sem IntelliSense, sem verificações em tempo de compilação na forma da solicitação.

3. Superfície de API v1.x Pequena: O corpo JSON documentado aceita apenas um campo html. URL-para-PDF, folhas de estilo personalizadas, cabeçalhos/rodapés, tamanho de página, orientação e margens são listados como itens do roteiro em vez de recursos fornecidos — qualquer coisa além de renderizar uma string de HTML deve ser expressa no próprio HTML, geralmente via @page CSS e divs com posição absoluta.

4. Sem Suporte a Numeração de Páginas: A API não possui substituições {page}/ {total}, então rodapés "Página X de Y" não podem ser produzidos no servidor.

5. Viagem de Ida e Volta HTTP por PDF: Mesmo quando o contêiner está em execução em localhost, cada PDF paga pela serialização JSON e um salto de socket.

6. Marca d'água no Nível Gratuito: Sem a variável de ambiente KAIZEN_PDF_LICENSE configurada no contêiner, a saída é marcada com uma marca d'água.

Comparação entre Kaizen.io e IronPDF

Para equipes padronizando no moderno .NET, o IronPDF remove o contêiner sidecar e o salto HTTP do caminho da solicitação enquanto expõe uma superfície de configuração fortemente tipada.

Esforço estimado por funcionalidade

Mudança de paradigma

A mudança fundamental é de chamadas HTTP fora do processo para um contêiner Docker para renderização em processo:

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

Pré-requisitos

1. .NET Environment: .NET Framework 4.6.2+ or .NET Core 3.1+ / .NET 5+
2. Acesso ao NuGet : Capacidade de instalar pacotes NuGet.
3. Licença do IronPDF: Obtenha sua chave de licença em IronPDF

Alterações no pacote

Não há pacote NuGet do Kaizen para remover — Kaizen é enviado apenas como imagem Docker. Pare o contêiner e adicione o pacote 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

Configuração de licença

// 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 o uso do Kaizen.io

Como a Kaizen não tem SDK, as chamadas para ela parecem POSTs HttpClient genéricos. Procure pelo endpoint, nome da imagem e variável de licença env em vez de um namespace:

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

Mapeamentos de Conceito

Não há uma classe .NET do Kaizen para mapear — apenas a forma da solicitação JSON e as convenções que você construiu em torno dela.

Mapeamentos de espaço reservado

Kaizen v1.x não tem espaços reservados no lado do servidor. Se anteriormente você substituiu manualmente strings no HTML antes de POSTar, mude para os placeholders de tempo de renderização do IronPDF:

Exemplo 1: HTML básico para PDF

Antes (Kaizen.io — POST JSON para o contêiner):

// 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

Apó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

A abordagem Kaizen.io serializa JSON, posta-o no endpoint REST do contêiner, verifica o código de status, lê a resposta como bytes e escreve esses bytes no disco. O ChromePdfRenderer do IronPDF é executado em processo — RenderHtmlAsPdf() retorna um PdfDocument com um método SaveAs(), então a viagem de ida e volta e o manuseio manual de bytes são eliminados. Consulte a documentação de conversão de HTML para PDF para obter opções de renderização adicionais.

Exemplo 2: Converter arquivo HTML para PDF com configurações de página

Kaizen v1.x não tem endpoint de arquivo e nem campos de layout de página — você mesmo lê o arquivo e incorpora tamanho/orientação da página em @page CSS.

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

Apó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() lê o arquivo diretamente, e o tamanho da página e a orientação mudam de CSS @page para propriedades RenderingOptions.

Exemplo 3: URL para PDF com cabeçalhos e rodapés

Kaizen v1.x não tem ConvertUrl, nem campos de cabeçalho/rodapé, nem substituições de número de página. A solução alternativa é buscar a página você mesmo e envolvê-la com CSS @page e divs com posição fixa para simular cabeçalho/rodapé — sem maneira de renderizar números de página.

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

Apó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() busca e renderiza a URL diretamente — sem busca de página no lado do cliente — e os divs com posição fixa simulados são substituídos por zonas TextHeader / TextFooter. Os números de página são produzidos via os substitutos {page}e {total-pages}, que Kaizen v1.x não fornece. Saiba mais sobre conversão de URL para PDF e cabeçalhos e rodapés.

Licença Residindo no Código, Não no Contêiner

A licença do Kaizen é configurada via a variável de ambiente KAIZEN_PDF_LICENSE no contêiner Docker. A licença do IronPDF é uma propriedade estática definida uma vez na inicialização do aplicativo:

// 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()

Sintaxe de Espaço Reservado

Se anteriormente você substituiu manualmente strings no HTML antes de POSTar, mude para os placeholders de tempo de renderização do IronPDF:

• {page}(sem alteração)
• {total}→ {total-pages}
• {title}→ {html-title}
• {date}→ {date}(sem alteração)

Alteração do tipo de retorno

Kaizen retorna bytes brutos via HTTP. O IronPDF retorna um 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

Delete a Infraestrutura HTTP

Uma vez que o renderizador está em processo, o código de suporte 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);

Questão 1: Não há Classe HtmlToPdfConverter

Problema: Não há classe HtmlToPdfConverter para trocar — Kaizen não tem SDK .NET nenhum.

Solução: A migração é de POSTs HttpClient contra o contêiner para 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)

Questão 2: Onde Foi o Objeto de Opções?

Problema: Kaizen v1.x não tem ConversionOptions — o layout da página era CSS @page em linha, cabeçalhos/rodapés eram divs com posição fixa.

Solução: Mover essa configuração para RenderingOptions no 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

Questão 3: Números de Página Não Renderizam

Problema: Kaizen v1.x não tem suporte a substituições {page}/ {total}, então qualquer rodapé "Página X de Y" pré-migração estava ausente ou era texto estático.

Solução: Use os espaços reservados de cabeçalho/rodapé do 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}"
}

Se você anteriormente substituiu manualmente {total}no seu próprio código antes de postar, remova essa substituição —IronPDF resolve {total-pages}no momento da renderização.

Questão 4: Erros de Conexão do Contêiner

Problema: Caminhos de código lidando com erros "contêiner inacessível" / porta-8080.

Solução:IronPDF roda em processo — não há endpoint para conectar-se. Delete o tratamento de erros de conexão.

Problema 5: Primeira renderização lenta

Problema: A primeira geração do PDF leva de 1 a 3 segundos.

Solução: O IronPDF inicializa o Chromium no primeiro uso. Aquecimento na inicialização do aplicativo:

// 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>")

Pré-migração

• Localize todos os sites de chamada do Kaizen (procure por html-to-pdf, KAIZEN_PDF_LICENSE, kaizenio.azurecr.io, localhost:8080)
• Documentar CSS @page em linha usado para tamanho, orientação, margens
• Documente divs de cabeçalho/rodapé falsos (posição fixa com deslocamentos negativos)
• Listar qualquer substituição de placeholders no lado do cliente (html.Replace("{page}", ...) etc.)
• Observe o ciclo de vida do contêiner: pull, run, restart, variável de licença env
• Obtenha a chave de licença do IronPDF

Desmontagem de Container

• Parar e remover o contêiner Kaizen em execução (docker stop kaizen-pdf && docker rm kaizen-pdf)
• Remova etapas de pull/run do Kaizen do CI/CD
• Remova KAIZEN_PDF_LICENSE de segredos/ambiente
• Instale o pacoteNuGet IronPdf(dotnet add package IronPdf)

Alterações no código

• Adicionar configuração de chave de licença na inicialização
• Substitua o POST HttpClient por ChromePdfRenderer
• Mova CSS @page incorporado para propriedades RenderingOptions
• Substitua o POST JSON por RenderHtmlAsPdf() / RenderHtmlFileAsPdf() / RenderUrlAsPdf()
• Substitua divs de cabeçalho/rodapé falsos por TextHeader/Footer ou HtmlHeader/Footer
• Atualizar sintaxe de substitutes ({total}→ {total-pages}, {title}→ {html-title})
• Substitua o corpo HTTP byte[] por pdf.BinaryData
• Use pdf.SaveAs() em vez de File.WriteAllBytes()
• Exclua o tratamento de erros de acessibilidade do container e a tentativa/retrocesso

Testando

• Testar todos os caminhos de geração de PDF
• Verifique a renderização do cabeçalho/rodapé e números de página (nova capacidade)
• Valide margens, tamanho da página e orientação
• Teste operação offline (nenhum container necessário)

Pós-migração

• Desmonte a infraestrutura de container Kaizen
• Atualize variáveis de ambiente / segredos
• Remova verificações de saúde do container de monitoramento/alertas
• Documente os novos padrões de erro de exceção tipada