Jak przeprowadzić migrację z Kaizen.io do IronPDF w języku C#

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.

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

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"

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

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

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

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

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

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

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

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

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.

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

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

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

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

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)

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

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

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

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