Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migration de gotenberg vers IronPdf
GUIDES DE MIGRATION

Comment migrer de C# à IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

Migrer d'IronPDF à IronPdf : Guide complet de migration vers C

La migration deIronPDFversIronPDFtransforme votre flux de travail PDF .NET d'une architecture microservice basée sur Docker avec des appels d'API HTTP vers une bibliothèque C# native en cours de processus. Ce guide fournit un chemin de migration complet, étape par étape, qui élimine la surcharge de l'infrastructure, la latence du réseau et la complexité de la gestion des conteneurs pour les développeurs .NET professionnels.

Pourquoi migrer de Gotenbergà IronPDF

Le problème de l'architecture de Gotenberg

Gotenberg est une architecture de microservices basée sur Docker pour la génération de PDF. Bien que puissant et flexible, il introduit une complexité importante pour les applications C# :

  1. Frais généraux d'infrastructure : Nécessite Docker, l'orchestration de conteneurs (Kubernetes/Docker Compose), la découverte de services et l'équilibrage de charge. Chaque déploiement devient plus complexe.

  2. Latence du réseau : chaque opération PDF nécessite un appel HTTP à un service distinct, ce qui ajoute entre 10 et 100 ms par requête. Cette latence s'aggrave rapidement dans les scénarios à fort volume.

  3. Problèmes de démarrage à froid : Le démarrage du conteneur peut ajouter 2 à 5 secondes aux premières demandes. Chaque redémarrage de pod, chaque événement de mise à l'échelle et chaque déploiement déclenche des démarrages à froid.

  4. Complexité opérationnelle : vous devez gérer la santé, la mise à l'échelle, la journalisation et la surveillance des conteneurs séparément de votre application principale.

  5. Données de formulaire multipartites : Chaque requête nécessite la construction de données utiles multipartites/formulaires - verbeuses, sujettes aux erreurs et fastidieuses à maintenir.

  6. Points de défaillance : les pannes de réseau, l'indisponibilité des services et les pannes de conteneurs relèvent de votre responsabilité.

  7. Gestion de la version : Les images de Gotenbergsont mises à jour séparément de votre application ; Les modifications de l'API peuvent interrompre les intégrations de manière inattendue.

Comparaison Gotenbergvs IronPDF

Aspect Gotenberg IronPDF
Déploiement Conteneur Docker + orchestration Paquet NuGet unique
Architecture Microservice (API REST) Bibliothèque en cours
Temps de latence par requête 10-100ms+ (aller-retour sur le réseau) temps de latence < 1ms
Démarrage à froid 2-5 secondes (démarrage du conteneur) 1-2 secondes (premier rendu uniquement)
Infrastructure Docker, Kubernetes, équilibreurs de charge Aucune exigence
Modes de défaillance Réseau, conteneur, défaillance de service Exceptions .NET Standard
Style API REST multipart/form-data Appels de méthodes C# natifs
Mise à l'échelle Horizontal (plus de conteneurs) Vertical (en cours)
Débogage Traçage distribué nécessaire Débogueur standard
Contrôle de version Balises de l'image du conteneur Versions des paquets NuGet

Pour les équipes qui prévoient l'adoption de .NET 10 et C# 14 jusqu'en 2025 et 2026,IronPDFconstitue une base à l'épreuve du temps, sans aucune dépendance à l'égard de l'infrastructure, qui s'intègre nativement aux modèles .NET modernes.

Évaluation de la complexité de la migration

Estimation de l'effort par fonctionnalité

Fonction Complexité de la migration Notes
HTML vers PDF Très faible Remplacement direct de la méthode
URL vers PDF Très faible Remplacement direct de la méthode
Format de papier personnalisé Faible Configuration basée sur les propriétés
Marges Faible Conversion des unités (pouces → mm)
Fusion de PDF Faible Appel de méthode statique
En-têtes/Pieds de page Moyen Syntaxe différente pour les espaces réservés
Délais d'attente Faible Chaîne en millisecondes
Conversion PDF/A Faible Appel de méthode au lieu de paramètre

Changement de paradigme

Le changement fondamental dans cette migration C# consiste à passer des appels API HTTP avec des données de formulaire multiparties aux appels de méthode C# natifs :

Gotenberg :  HTTP POST multipart/form-data vers un conteneur Docker
IronPDF :    Appels directs de méthodes sur des objets C#

Avant de commencer

Prérequis

  1. <Version .NET :IronPDFprend en charge .NET Framework 4.6.2+ et .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. <Clé de licence : Obtenez votre clé de licenceIronPDFà partir de ironpdf.com
  3. Planifier le retrait de l'infrastructure : Documenter les conteneurs Gotenbergpour le démantèlement après la migration

Identifier tous les usages de Gotenberg

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

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

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

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

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

Modifications du paquet NuGet

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

# Install IronPDF
dotnet add package IronPdf
# Remove Gotenbergclient (if using)
dotnet remove package Gotenberg.Sharp.API.Client

# Install IronPDF
dotnet add package IronPdf
SHELL

Migration rapide

Étape 1 : Mise à jour de la configuration de la licence

Avant (Gotenberg):

Gotenberg ne nécessite pas de licence mais requiert une infrastructure Docker avec des URL de conteneurs.

private readonly string _gotenbergUrl = "http://localhost:3000";
private readonly string _gotenbergUrl = "http://localhost:3000";
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Après (IronPDF):

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";
// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Étape 2 : mise à jour des importations de l'espace de noms

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

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;
// Before (Gotenberg)
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Référence API complète

Mappage du point d'extrémité de Gotenbergà IronPDF

Route de Gotenberg Équivalent d'IronPDF Notes
POST /forms/chromium/convert/html ChromePdfRenderer.RenderHtmlAsPdf() Chaîne HTML vers PDF
POST /forms/chromium/convert/url ChromePdfRenderer.RenderUrlAsPdf() URL vers PDF
POST /forms/pdfengines/merge PdfDocument.Merge() Fusionner plusieurs PDF
POST /forms/pdfengines/convert pdf.SaveAs() avec paramètres Conversion PDF/A
GET /health N/A Aucun service externe n'est nécessaire

Mappage des paramètres de formulaire aux options de rendu

Paramètre Gotenberg Propriété d'IronPDF Notessur la conversion
largeur du papier (pouces) RenderingOptions.PaperSize Utiliser une énumération ou une taille personnalisée
hauteur du papier (pouces) RenderingOptions.PaperSize Utiliser une énumération ou une taille personnalisée
marginTop (pouces) RenderingOptions.MarginTop Multiplier par 25,4 pour obtenir mm
marginBottom (pouces) RenderingOptions.MarginBottom Multiplier par 25,4 pour obtenir mm
printBackground RenderingOptions.PrintHtmlBackgrounds Booléen
paysage RenderingOptions.PaperOrientation Landscape enum
waitDelay RenderingOptions.RenderDelay Convertir en millisecondes

Exemples de migration de code

Exemple 1 : HTML de base vers PDF

Avant (Gotenberg):

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

class GotenbergExample
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Hello from Gotenberg</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
        Console.WriteLine("PDF generated successfully");
    }
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergExample
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Hello from Gotenberg</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
        Console.WriteLine("PDF generated successfully");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Après (IronPDF):

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

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var html = "<html><body><h1>Hello from IronPDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF generated successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var html = "<html><body><h1>Hello from IronPDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF generated successfully");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

La différence est substantielle : Gotenbergnécessite la construction d'un HttpClient, la construction d'un MultipartFormDataContent, la réalisation d'un POST HTTP asynchrone vers un conteneur Docker en cours d'exécution et le traitement de la réponse sous forme de tableau d'octets.IronPDFréduit cela à trois lignes avec un appel de méthode ChromePdfRenderer-pas de surcharge réseau, pas de dépendance au conteneur, pas de complexité asynchrone. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.

Exemple 2 : Conversion d'une URL en PDF

Avant (Gotenberg):

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

class GotenbergUrlToPdf
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        content.Add(new StringContent("https://example.com"), "url");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
        Console.WriteLine("PDF from URL generated successfully");
    }
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergUrlToPdf
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        content.Add(new StringContent("https://example.com"), "url");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
        Console.WriteLine("PDF from URL generated successfully");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Après (IronPDF):

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

class IronPdfUrlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://example.com");

        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL generated successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfUrlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://example.com");

        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL generated successfully");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

L'approche de Gotenbergnécessite un point d'arrivée différent (/forms/chromium/convert/url), la construction d'un contenu multipartite avec l'URL comme champ de formulaire et la gestion de réponses HTTP asynchrones. La méthode RenderUrlAsPdf() d'IronPDF accepte directement l'URL et renvoie un objet PdfDocument de manière synchrone. En savoir plus sur la conversion d'URL en PDF.

Exemple 3 : Taille du papier et marges personnalisées

Avant (Gotenberg):

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

class GotenbergCustomSize
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        content.Add(new StringContent("8.5"), "paperWidth");
        content.Add(new StringContent("11"), "paperHeight");
        content.Add(new StringContent("0.5"), "marginTop");
        content.Add(new StringContent("0.5"), "marginBottom");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes);
        Console.WriteLine("Custom size PDF generated successfully");
    }
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergCustomSize
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";

        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        content.Add(new StringContent("8.5"), "paperWidth");
        content.Add(new StringContent("11"), "paperHeight");
        content.Add(new StringContent("0.5"), "marginTop");
        content.Add(new StringContent("0.5"), "marginBottom");

        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();

        await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes);
        Console.WriteLine("Custom size PDF generated successfully");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Après (IronPDF):

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

class IronPdfCustomSize
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("custom-size.pdf");
        Console.WriteLine("Custom size PDF generated successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Rendering;

class IronPdfCustomSize
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;

        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        pdf.SaveAs("custom-size.pdf");
        Console.WriteLine("Custom size PDF generated successfully");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Gotenberg exige des paramètres à base de chaînes ("8.5", "11", "0.5") ajoutés aux données des formulaires multipartites - pas de sécurité de type, pas d'IntelliSense, facile à taper par erreur.IronPDFfournit des propriétés fortement typées avec des enums PdfPaperSize et des valeurs de marge numériques. Notez que les marges d'IronPDF sont en millimètres (50mm ≈ 2 pouces), alors que Gotenbergutilise des pouces.

Notesde migration essentielles

Conversions d'unités

La conversion la plus importante dans cette migration Gotenbergest celle des unités de marge :

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

// IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7;    // 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4; // 1 inch × 25.4 = 25.4mm
// Gotenberg: margins in inches
content.Add(new StringContent("0.5"), "marginTop");    // 0.5 inches
content.Add(new StringContent("1"), "marginBottom");   // 1 inch

// IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7;    // 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4; // 1 inch × 25.4 = 25.4mm
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Formule de conversion : millimètres = pouces × 25,4

Synchrone vs Asynchrone

Gotenberg nécessite des opérations asynchrones en raison de la communication HTTP :

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

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

// IronPDF: Async wrapper if needed
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
// Gotenberg: Forced async due to network calls
var response = await client.PostAsync(gotenbergUrl, content);
var pdfBytes = await response.Content.ReadAsByteArrayAsync();

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

// IronPDF: Async wrapper if needed
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Gestion des erreurs

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

// IronPDF: Standard .NET exceptions
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
}
catch (Exception ex)
{
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
// Gotenberg: HTTP error handling
try
{
    var response = await client.PostAsync(gotenbergUrl, content);
    response.EnsureSuccessStatusCode();  // What if 500? 503? Timeout?
}
catch (HttpRequestException ex) { /* Network error */ }
catch (TaskCanceledException ex) { /* Timeout */ }

// IronPDF: Standard .NET exceptions
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
}
catch (Exception ex)
{
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Suppression de l'infrastructure

Après la migration, supprimez Gotenbergde votre infrastructure :

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

Considérations de Performance

Comparaison de latence

Opération Gotenberg(Chaud) Gotenberg(Démarrage à froid) IronPDF(premier rendu) IronPDF(suite)
HTML simple 150-300ms 2 à 5 secondes 1-2 secondes 50-150ms
HTML complexe 500-1500ms 3-7 secondes 1.5-3 secondes 200-800ms
Rendu d'URL 1-5 secondes 3-10 secondes 1-5 secondes 500ms-3s

Élimination des coûts d'infrastructure

Ressource Gotenberg IronPDF
Conteneurs requis 1-N (mise à l'échelle) 0
Mémoire par conteneur 512MB-2GB N/A
Frais généraux de réseau par requête 10-100ms 0ms
Points d'arrivée du bilan de santé Les exigences sont les suivantes Pas nécessaire
Équilibreur de charge Souvent nécessaire Pas nécessaire

Dépannage

Édition 1 : Les modèles HttpClient ne sont pas nécessaires

Problème : Le code utilise encore HttpClient et MultipartFormDataContent.

Solution : Remplacer entièrement par ChromePdfRenderer :

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

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

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Enjeu 2 : Les unités de marge ne sont pas les bonnes

Problème : Les PDF ont des marges incorrectes après la migration.

Solution : Convertissez les pouces en millimètres :

// Gotenbergused inches: "0.5"
//IronPDFuses millimeters: 0.5 × 25.4 = 12.7
renderer.RenderingOptions.MarginTop = 12.7;
// Gotenbergused inches: "0.5"
//IronPDFuses millimeters: 0.5 × 25.4 = 12.7
renderer.RenderingOptions.MarginTop = 12.7;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Sujet 3 : Références URL des conteneurs

Problème : Le code contient http://gotenberg:3000 ou des URL similaires.

Solution : Supprimez toutes les références URL du conteneur :IronPDFs'exécute en cours de processus :

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

//IronPDFneeds no URL - it's in-process
var renderer = new ChromePdfRenderer();
// Remove:
// private readonly string _gotenbergUrl = "http://gotenberg:3000";

//IronPDFneeds no URL - it's in-process
var renderer = new ChromePdfRenderer();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Liste de contrôle de la migration

Pré-migration

  • [Inventaire de tous les appels HTTP de Gotenbergdans la base de code
  • [Documenter la configuration actuelle de Gotenberg(délais, marges, tailles de papier)
  • [Identifier toutes les configurations Docker/Kubernetes Gotenberg
  • [Obtenir la clé de licence IronPDF
  • [ ] Planifier le déclassement d'une infrastructure

Migration de code

  • [Installer le paquet NuGet IronPdf : dotnet add package IronPdf
  • [Supprimer les paquets clients de Gotenberg
  • [Remplacer tous les appels HTTP àIronPDFpar des appels de méthode IronPDF
  • [ ] Convertir les unités de marge de pouces en millimètres
  • [Mise à jour de la gestion des erreurs (erreurs HTTP → exceptions .NET)
  • [Ajouter l'initialisation de la clé de licence au démarrage

Migration des infrastructures

  • [Supprimer Gotenbergde Docker Compose / Kubernetes
  • [Mise à jour des pipelines CI/CD (supprimer les images de Gotenberg)
  • [Supprimer les contrôles de santé de Gotenberg
  • [Supprimer l'URL de Gotenbergde la configuration

Testing

  • [Test de conversion HTML vers PDF
  • [Test de conversion d'URL en PDF
  • [Vérifier l'exactitude des marges et des tailles
  • [Test de performance en charge
  • [Test du temps d'échauffement du premier preneur d'ordre

Post-Migration

  • [Supprimer les déploiements de conteneurs de Gotenberg
  • [Archiver les fichiers de configuration de Gotenberg
  • [Mise à jour de la documentation
  • [ ] Surveiller l'utilisation de la mémoire de l'application
  • [Vérifier qu'il n'y a pas de connexions réseau orphelines

Conclusion

La migration de GotenbergversIronPDFélimine la complexité de l'infrastructure Docker, supprime la latence réseau de chaque opération PDF et remplace la construction verbeuse de données de formulaires multipartites par des appels de méthodes C# propres et à sécurité de type. Le résultat est un déploiement plus simple, une latence plus faible, moins de points de défaillance et un débogage plus facile, tout en conservant des capacités de rendu HTML/CSS/JavaScript complètes grâce au moteur Chromium intégré d'IronPDF.

Les principaux changements apportés à cette migration sont les suivants :

  1. Architecture : Appels API REST → Méthodes C# natives
  2. Infrastructure : Conteneurs Docker → Paquet NuGet
  3. Unités : Pouces → Millimètres pour les marges
  4. Gestion des erreurs : codes d'état HTTP → exceptions .NET
  5. Latence : Aller-retour sur le réseau → Exécution en cours de processus

Explorez la documentation complète IronPDF, tutoriel, et référence API pour accélérer votre migration vers IronPDF.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit