Migracja z Kaizen.io HTML-do-PDF na IronPDF zastępuje hostowany samodzielnie kontener Docker eksponowany przez HTTP biblioteką .NET w procesie.Kaizen.io HTML-to-PDFjest dostarczany wyłącznie jako obraz Docker kaizenio.azurecr.io/html-to-pdf i udostępnia pojedynczy punkt końcowy REST na POST /html-to-pdf na porcie 8080 — nie ma oficjalnego .NET SDK ani pakietu NuGet, więc każde wywołanie C# musi być napisane ręcznie HttpClient w odniesieniu do uruchomionego kontenera. Ten przewodnik opisuje, jak zamienić ten wzorzec na ChromePdfRenderer IronPDF.

Dlaczego warto przejść z Kaizen.io na IronPDF

Wyzwania API kontenerowego

Kaizen.io HTML-to-PDF to kontener Docker z celowo małym API v1.x, a integracja C# to cokolwiek zbudujesz sam na szczycie HttpClient. Ten kształt ma realne ograniczenia w produkcji:

1. Kontener do obsługi: Uruchamiasz, monitorujesz i aktualizujesz kaizenio.azurecr.io/html-to-pdf:latest w miejscu dostępnym z Twojej aplikacji — lokalny Docker, sidecar lub osobny host.

2. Brak .NET SDK: Każde wywołanie C# jest pisane ręcznie HttpClient POST + JSON. Brak IntelliSense, brak kontroli w czasie kompilacji na kształcie żądania.

3. Mała powierzchnia API v1.x: Dokumentowane ciało JSON akceptuje tylko pole html. Przekonwertowanie URL na PDF, niestandardowe arkusze stylów, nagłówki/stopki, rozmiar strony, orientacja i marginesy są wymienione jako elementy na mapie drogowej, a nie jako funkcje dostarczone — cokolwiek poza renderowaniem ciągu HTML musi być wyrażone wewnątrz samego HTML, zazwyczaj za pomocą @page CSS i divów z ustaloną pozycją.

4. Brak obsługi numerów stron: API nie ma placeholderów {page}/ {total}, więc stopki 'Strona X z Y' nie mogą być generowane po stronie serwera.

5. Podróż HTTP dla każdego PDF: Nawet gdy kontener działa na localhost, każdy PDF wiąże się z serializacją JSON i przeskokiem socketu.

6. Znak wodny w darmowej wersji: Bez ustawionej zmiennej KAIZEN_PDF_LICENSE w środowisku na kontenerze, wynik posiada znak wodny.

Porównanie Kaizen.io i IronPDF

Dla zespołów standaryzujących się na współczesnym .NET,IronPDF usuwa boczny kontener i przeskok HTTP ze ścieżki żądania, wzmacniając powierzchnię konfiguracji silnie typowanej.

Ocena złożoności migracji

Szacowany nakład pracy według funkcji

Zmiana paradygmatu

Podstawowe przesunięcie to z wywołań HTTP poza procesem do konteneru Docker do renderowania w procesie:

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

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

Zanim zaczniesz

Wymagania wstępne

1. Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5+
2. Dostęp do NuGet: Możliwość instalowania pakietów NuGet
3. Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie

Nie ma pakietu NuGet dla Kaizen do usunięcia — Kaizen jest dostarczany tylko jako obraz Docker. Zatrzymaj kontener i dodaj pakiet 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

Konfiguracja licencji

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

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

Zidentyfikuj zastosowanie Kaizen.io

Ponieważ Kaizen nie ma SDK, wywołania do niego wyglądają jak ogólne HttpClient POST. Szukaj punktu końcowego, nazwy obrazu i zmiennej środowiskowej licencji zamiast przestrzeni nazw:

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

Kompletna dokumentacija API

Mapowanie Konceptów

Nie ma klasy .NET dla Kaizen do mapowania — tylko kształt żądania JSON i konwencje, które zbudowałeś wokół niego.

Mapowanie symboli zastępczych

Kaizen v1.x nie ma miejsc po stronie serwera. Jeśli wcześniej samodzielnie zamieniałeś ciągi w HTML przed wysłaniem POST, przejdź na zastępstwa renderowane w czasie przez IronPDF:

Przykłady migracji kodu

Przykład 1: Podstawowy HTML do PDF

Przed (Kaizen.io — wysyłanie JSON do kontenera):

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

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

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

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

Podejście Kaizen.io serializuje JSON, wysyła go do punktu końcowego REST kontenera, sprawdza kod statusu, odczytuje odpowiedź jako bajty i zapisuje te bajty na dysku. Filzja ChromePdfRendererIronPDF działa w procesie — RenderHtmlAsPdf() zwraca PdfDocument z SaveAs() method, więc podróż w obie strony i ręczne przetwarzanie bajtów znikają. Dodatkowe opcje renderowania można znaleźć w dokumentacji dotyczącej konwersji HTML do PDF.

Przykład 2: Plik HTML do formatu PDF z ustawieniami strony

Kaizen v1.x nie ma punktu końcowego pliku ani pól układu strony — musisz samodzielnie odczytać plik i osadzić rozmiar/orientację strony w @page CSS.

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

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

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

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() odczytuje plik bezpośrednio, a rozmiar i orientacja strony przechodzi z wbudowanego @page CSS do RenderingOptions właściwości.

Przykład 3: URL do pliku PDF z nagłówkami i stopkami

Kaizen v1.x nie ma ConvertUrl, nie ma pól nagłówka/stopki ani placeholderów numerów stron. Obejściem jest samodzielne pobranie strony i opakowanie jej za pomocą @page CSS i divów z ustaloną pozycją, aby sfingować nagłówek/stopkę — brak sposobu na renderowanie numerów stron.

Przed (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());
    }
}

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

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() pobiera i renderuje URL bezpośrednio — brak pobrania strony po stronie klienta — a sfingowane divy z ustalonym położeniem są zastępowane TextHeader / TextFooter strefami. Numery stron są produkowane za pomocą placeholderów {page}i {total-pages}, których Kaizen v1.x nie dostarcza. Dowiedz się więcej o konwersji URL na PDF i nagłówkach i stopkach.

Ważne uwagi dotyczące migracji

Licencja znajduje się w kodzie, nie w kontenerze

Licencja Kaizen jest konfigurowana za pomocą zmiennej środowiskowej KAIZEN_PDF_LICENSE na kontenerze Docker. Licencja IronPDF jest ustawiana jako właściwość statyczna, jednorazowo przy uruchomieniu aplikacji:

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

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

Składnia zastępczego miejsca

Jeśli wcześniej samodzielnie zamieniałeś ciągi w HTML przed wysłaniem POST, przejdź na zastępstwa renderowane w czasie przez IronPDF:

• {page}(bez zmian)
• {total}→ {total-pages}
• {title}→ {html-title}
• {date}→ {date}(bez zmian)

Zmiana typu zwracanej wartości

Kaizen zwraca surowe bajty przez HTTP.IronPDF zwraca 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

Usuń hydraulikę HTTP

Gdy renderer jest w procesie, wspierający kod znika:

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

net

net

Rozwiązywanie problemów

Problem 1: Brak klasy HtmlToPdfConverter

Problem: Nie ma HtmlToPdfConverter klasy do zamiany — Kaizen nie ma w ogóle .NET SDK.

Rozwiązanie: Migracja odbywa się z HttpClient POST do kontenera na 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)

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)

Problem 2: Gdzie jest obiekt opcji?

Problem: Kaizen v1.x nie ma ConversionOptions — układ strony był wbudowany w @page CSS, nagłówki/stopki były divami z ustaloną pozycją.

Rozwiązanie: Przenieś tę konfigurację do RenderingOptions na rendererze:

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

' 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

Problem 3: Numery stron nie są renderowane

Problem: Kaizen v1.x nie ma wsparcia dla placeholderów {page}/ {total}, więc każda stopka 'Strona X z Y' przed migracją była albo brakująca, albo statycznym tekstem.

Rozwiązanie: Wykorzystaj zastępcze miejsca dla nagłówków/stopków 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}"
}

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

Jeśli wcześniej ręcznie zamieniałeś {total}w swoim kodzie przed POSTowaniem, usuń tę zamianę —IronPDF rozwiązuje {total-pages}w czasie renderowania.

Problem 4: Błędy połączenia z kontenerem

Problem: Ścieżki kodu obsługujące błędy "kontener nieosiągalny" / port-8080.

**Rozwiązanie:**IronPDF działa w procesie — nie ma punktu końcowego do podłączenia. Usuń obsługę błędów połączenia.

Problem 5: Powolne pierwsze renderowanie

Problem: Wygenerowanie pierwszego pliku PDF zajmuje 1–3 sekundy.

**Rozwiązanie:**IronPDF uruchamia Chromium przy pierwszym użyciu. Rozgrzewka przy uruchomieniu aplikacji:

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

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

Lista kontrolna migracji

Przed migracją

• Zlokalizuj każde miejsce wywołania Kaizen (szukaj html-to-pdf, KAIZEN_PDF_LICENSE, kaizenio.azurecr.io, localhost:8080)
• Udokumentuj wbudowany @page CSS użyty dla rozmiaru, orientacji, marginesów
• Dokumentuj fałszywe nagłówki/stopki (divy z ustaloną pozycją z negatywnymi offsetami)
• Wymień każdy substytut placeholdera po stronie klienta (html.Replace("{page}", ...) itd.)
• Zanotuj cykl życia kontenera: pobierz, uruchom, zrestartuj, zmienna środowiskowa licencji
• Uzyskaj klucz licencyjny IronPDF

Rozbiórka kontenera

• Zatrzymaj i usuń uruchomiony kontener Kaizen (docker stop kaizen-pdf && docker rm kaizen-pdf)
• Usuń kroki pobierania/uruchamiania Kaizen z CI/CD
• Usuń KAIZEN_PDF_LICENSE z tajemnic/środowiska
• Zainstaluj pakietNuGet IronPdf(dotnet add package IronPdf)

Zmiany w kodzie

• Dodaj konfigurację klucza licencyjnego podczas uruchamiania
• Zastąp HttpClient POST z ChromePdfRenderer
• Przenieś osadzony @page CSS do właściwości RenderingOptions
• Zastąp POST JSON z RenderHtmlAsPdf() / RenderHtmlFileAsPdf() / RenderUrlAsPdf()
• Zastąp sfingowane divy nagłówka/stopki z TextHeader/Footer lub HtmlHeader/Footer
• Zaktualizuj składnię placeholderów ({total}→ {total-pages}, {title}→ {html-title})
• Zastąp ciało HTTP byte[] z pdf.BinaryData
• Użyj pdf.SaveAs() zamiast File.WriteAllBytes()
• Usuń obsługę błędów i retry/backoff dotyczące osiągalności kontenera

Testowanie

• Przetestuj wszystkie ścieżki generowania plików PDF
• Zweryfikuj renderowanie nagłówków/stopków i numerów stron (nowa funkcjonalność)
• Zwaliduj marginesy, rozmiar strony i orientację
• Przetestuj działanie offline (kontener nie jest wymagany)

Po migracji

• Rozbierz infrastrukturę kontenera Kaizen
• Zaktualizuj zmienne środowiskowe / tajemnice
• Usuń kontrole zdrowia kontenera z monitoringu/alertów
• Dokumentuj nowe wzorce błędów z typizowanymi wyjątkami