.NET AIDE

Comment convertir HTML en PDF en Rust

Curtis Chau
Curtis Chau
Mis à jour : 18 octobre 2026

Convertir des fichiers HTML ou des chaînes HTML brutes en PDF est une exigence courante pour les factures, rapports et reçus. Rust ne dispose d’aucun moteur de rendu intégré pour cela, et en écrire un n’est pas un projet secondaire réaliste. L’analyse HTML est la partie facile. L’analyse CSS, la mise en page et la pagination sont les tâches interminables, ce qui fait du navigateur un choix naturel pour la génération de PDF en Rust. Ce tutoriel convertit du HTML en PDF en Rust avec le crate open-source headless_chrome, qui laisse Chrome effectuer le rendu et renvoie le PDF final à votre programme Rust.

Crate Headless Chrome pour Rust

headless_chrome est un crate Rust sous licence MIT qui contrôle un navigateur Chrome ou Chromium via le Chrome DevTools Protocol. Il peut ouvrir des pages, cliquer sur des éléments, prendre des captures d’écran et appeler la fonction d’impression en PDF intégrée de Chrome. Comme la page est rendue par un vrai navigateur, les mises en page CSS, les polices web et JavaScript fonctionnent de la même manière que dans Chrome.

Chrome peut également imprimer une page directement depuis la ligne de commande avec --print-to-pdf. Il s’agit simplement d’un appel CLI, donc les octets sont écrits sur le disque au lieu d’être dans votre programme, et les paramètres d’impression accessibles sont limités. Utiliser le DevTools Protocol permet de garder les octets dans votre programme et de laisser toute la plateforme web gérer la mise en page. C’est le même protocole sur lequel reposent les bibliothèques équivalentes dans d’autres langages. Le crate est maintenu par la communauté Rust, donc le support se fait via son issue tracker GitHub.

Prérequis

Pour créer un convertisseur HTML vers PDF en Rust, assurez-vous que les prérequis suivants sont en place :

  1. Rust 1.85 ou version ultérieure. Installez la toolchain Rust avec rustup. Sous Windows, la toolchain MSVC nécessite également une installation de Visual Studio, car rustc utilise son éditeur de liens et ses bibliothèques.
  2. Google Chrome, Chromium ou Microsoft Edge installé. headless_chrome recherche le navigateur dans le PATH, dans la variable d’environnement CHROME, et sous Windows dans le registre, avec Edge comme solution de secours.
  3. Connaissances de base de Rust et Cargo.

Ce tutoriel a été testé avec Rust 1.98.1, headless_chrome 1.0.22 et Chrome 153 sous Windows 11. Le même code fonctionne sous Linux et macOS.

Créer un projet Rust HTML vers PDF avec Cargo

Créez le projet binaire et ajoutez les deux dépendances depuis un terminal :

cargo new html_to_pdf
cd html_to_pdf
cargo add headless_chrome urlencoding
SHELL

L’étape 3 utilise le crate urlencoding pour transmettre la chaîne HTML à Chrome sous forme d’URL de données.

Comment convertir du HTML en PDF en Rust : Figure 1 - Création du projet et ajout des dépendances

Vérification de Cargo.toml

Après avoir exécuté cargo add, les deux crates apparaissent sous [dependencies] dans le fichier Cargo.toml :

[package]
name = "html_to_pdf"
version = "0.1.0"
edition = "2024"

[dependencies]
headless_chrome = "1.0.22"
urlencoding = "2.1.3"
Text

Comment convertir du HTML en PDF en Rust : Figure 2 - Dépendances Cargo.toml

La fonctionnalité par défaut offline du crate utilise un navigateur déjà installé. Si la machine cible ne dispose pas de Chrome, activez plutôt la fonctionnalité fetch (cargo add headless_chrome --features fetch) et le crate pourra télécharger une version de Chromium pour vous.

Étapes pour convertir du HTML en PDF en Rust

Étape 1 : Importation des crates

Ouvrez src/main.rs et remplacez son contenu par les imports nécessaires au programme. Browser et LaunchOptions démarrent Chrome, et PrintToPdfOptions contrôle la sortie PDF :

use std::fs;

use headless_chrome::types::PrintToPdfOptions;
use headless_chrome::{Browser, LaunchOptions};
Rust

Étape 2 : Lancement de Headless Chrome

Ensuite, démarrez un navigateur headless et ouvrez un onglet. main retourne un Result afin que chaque appel puisse utiliser l’opérateur ? au lieu de unwrap :

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Launch a headless Chrome instance
    let browser = Browser::new(LaunchOptions {
        headless: true,
        ..Default::default()
    })?;

    // Open a new tab to load the HTML into
    let tab = browser.new_tab()?;
Rust

Browser::default() donne le même résultat avec moins de code. LaunchOptions est montré ici car c’est là que vous pouvez définir la taille de la fenêtre, le chemin de Chrome ou le drapeau sandbox si besoin.

Étape 3 : Définition du contenu HTML

Fournissez maintenant le HTML qui doit devenir le PDF. La syntaxe de chaîne brute de Rust r#"..."# garde les guillemets du HTML lisibles :

    let html = r#"
        <html>
        <head>
            <style>
                body { font-family: Arial, sans-serif; margin: 40px; }
                h1 { color: #2a5db0; }
                table { border-collapse: collapse; width: 100%; }
                th, td { border: 1px solid #ccc; padding: 8px; text-align: left; }
                th { background-color: #f0f4fa; }
            </style>
        </head>
        <body>
            <h1>Hello, World!</h1>
            <p>This PDF was generated from an HTML string in Rust.</p>
            <table>
                <tr><th>Item</th><th>Quantity</th><th>Price</th></tr>
                <tr><td>Widget</td><td>2</td><td>$10.00</td></tr>
                <tr><td>Gadget</td><td>1</td><td>$25.00</td></tr>
            </table>
        </body>
        </html>
    "#;

    // Load the HTML string as a data URL and wait for the page to finish loading
    let data_url = format!("data:text/html;charset=utf-8,{}", urlencoding::encode(html));
    tab.navigate_to(&data_url)?.wait_until_navigated()?;
Rust

print_to_pdf n’a pas d’option HTML. Il imprime ce que l’onglet affiche, et le crate n’a pas de méthode pour définir directement le contenu de la page, donc la chaîne HTML est encodée en pourcentage dans une URL data: et l’onglet y navigue.

wait_until_navigated bloque ensuite jusqu’à ce que la page soit prête, et ne s’arrête pas à l’événement de chargement. Le crate active les événements du cycle de vie de Chrome et efface son indicateur de navigation à networkAlmostIdle, l’étape du cycle de vie du navigateur qui arrive une fois que les requêtes récupérées par la page (réseau inactif) se sont calmées. Au moment où l’onglet signale la fin de la navigation, les polices web et images tardives sont généralement en place.

Étape 4 : Conversion de HTML en PDF

Une fois la page chargée, appelez print_to_pdf. PrintToPdfOptions correspond aux paramètres d'impression de Chrome, et chaque champ est optionnel :

    // Print the page to PDF with background colors and 0.4 inch margins
    let options = PrintToPdfOptions {
        print_background: Some(true),
        margin_top: Some(0.4),
        margin_bottom: Some(0.4),
        margin_left: Some(0.4),
        margin_right: Some(0.4),
        ..Default::default()
    };
Rust

Les marges et tailles de papier sont en pouces. Sans paper_width et paper_height, Chrome utilise le format US Letter (8,5 x 11 pouces). Chrome n'imprimera pas les couleurs ou images d'arrière-plan sauf si vous le demandez. print_background est désactivé par défaut, et sans lui, l’ombrage de l’en-tête du tableau est supprimé du PDF.

Les champs de configuration de la page (landscape, scale, page_ranges, ainsi que les modèles d’en-tête et de pied de page) auront leur propre section plus loin dans ce tutoriel.

Étape 5 : Obtenir la sortie sous forme de vecteur d’octets

print_to_pdf retourne le document final sous forme de Vec<u8> conservé en mémoire. Rien n’est encore écrit sur le disque, donc les octets peuvent être envoyés vers un fichier, le corps d’une réponse HTTP, ou un stockage cloud :

    let pdf_data: Vec<u8> = tab.print_to_pdf(Some(options))?;
Rust

Étape 6 : Sauvegarder le fichier PDF

Pour sauvegarder le PDF, écrivez le vecteur d’octets dans un fichier avec std::fs::write, qui crée le fichier, écrit tous les octets et le ferme en une seule opération :

    // Write the PDF bytes to disk
    fs::write("output.pdf", &pdf_data)?;
    println!("PDF saved successfully ({} bytes).", pdf_data.len());

    Ok(())
}
Rust

Étape 7 : Nettoyage

Contrairement à l’API C de wkhtmltopdf, il n’y a pas de fonctions destroy ou deinit à appeler. Lorsque browser sort de la portée à la fin de main, son implémentation Drop arrête le processus Chrome et supprime le dossier de profil temporaire qu’il a créé. Si une étape échoue et que ? retourne prématurément, le même nettoyage s’exécute quand même.

Dans un service de longue durée, gardez un Browser vivant et ouvrez un nouvel onglet par document au lieu de lancer un nouveau processus Chrome pour chaque requête.

Étape 8 : Exécuter le code et générer le fichier PDF

Compilez et exécutez le projet depuis le dossier du projet :

cargo run
SHELL

La première compilation compile 143 crates, ce qui a pris 45 secondes sur la machine utilisée ici. Le programme affiche ensuite la taille du fichier généré :

Comment convertir du HTML en PDF en Rust : Figure 3 - sortie de cargo run

Le fichier output.pdf est enregistré dans le dossier du projet. Les styles CSS, y compris la couleur de l’en-tête et les bordures et arrière-plans du tableau, sont conservés :

Comment convertir du HTML en PDF en Rust : Figure 4 - Sortie PDF

Voici le output.pdf généré lui-même :

Convertir une URL ou un fichier HTML en PDF en Rust

Les mêmes appels navigate_to et print_to_pdf fonctionnent pour les pages web et les fichiers HTML locaux. Pour les fichiers locaux, ajoutez la crate url avec cargo add url afin de pouvoir transformer le chemin du fichier en une URL file:// valide sur chaque système d’exploitation.

L’exemple ci-dessous lit un modèle local, donc enregistrez ceci à côté de Cargo.toml sous le nom invoice.html :

<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 30px; }
        .box { background: #2a5db0; color: #fff; padding: 16px; }
    </style>
</head>
<body>
    <div class="box"><h2>Invoice #1024</h2></div>
    <p>Loaded from a local HTML file.</p>
</body>
</html>
HTML

Enregistrez le programme ci-dessous sous examples/url_and_file.rs et exécutez-le avec cargo run --example url_and_file :

use std::fs;

use headless_chrome::types::PrintToPdfOptions;
use headless_chrome::Browser;
use url::Url;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let browser = Browser::default()?;
    let tab = browser.new_tab()?;

    // Convert a live web page to PDF
    tab.navigate_to("https://doc.rust-lang.org/book/")?
        .wait_until_navigated()?;
    let url_pdf = tab.print_to_pdf(None)?;
    fs::write("url.pdf", url_pdf)?;

    // Convert a local HTML file to PDF
    let path = fs::canonicalize("invoice.html")?;
    let file_url = Url::from_file_path(&path).map_err(|_| "invalid file path")?;
    tab.navigate_to(file_url.as_str())?.wait_until_navigated()?;

    let options = PrintToPdfOptions {
        landscape: Some(true),
        print_background: Some(true),
        ..Default::default()
    };
    fs::write("invoice.pdf", tab.print_to_pdf(Some(options))?)?;

    println!("Saved url.pdf and invoice.pdf");
    Ok(())
}
Rust

Un onglet gère les deux documents l’un après l’autre. L’URL est imprimée avec les paramètres par défaut de Chrome, et la facture locale est imprimée en paysage avec ses couleurs d’arrière-plan :

Comment convertir du HTML en PDF en Rust : Figure 5 - URL et fichier HTML convertis en PDF

La page web capturée dans url.pdf :

Et le fichier HTML local imprimé dans invoice.pdf en mode paysage :

Enregistrez les modèles avec une extension .html, car Chrome décide comment traiter un fichier local à partir de l’extension d’entrée. Le même balisage enregistré sous .txt a été imprimé comme balises visibles au lieu d’une page rendue.

Taille de page, numéros de page et sauts de page

PrintToPdfOptions reflète la boîte de dialogue d’impression de Chrome, et ses valeurs prises en charge sont celles proposées par la boîte de dialogue elle-même. landscape: Some(true) passe en mode paysage, scale prend un facteur de zoom où 1.0 correspond à la taille réelle, et page_ranges prend une chaîne basée sur 1 telle que "1-5, 8, 11-13".

Les numéros de page peuvent venir de chaque côté. Donnez à Chrome un modèle de pied de page et il substitue pageNumber et totalPages sur chaque page :

let options = PrintToPdfOptions {
    display_header_footer: Some(true),
    header_template: Some("<span></span>".into()),
    footer_template: Some(
        "<div style='font-size:10px;width:100%;text-align:center'>Page <span class='pageNumber'></span> of <span class='totalPages'></span></div>".into()),
    margin_bottom: Some(0.6),
    ..Default::default()
};
Rust

La méthode CSS fonctionne aussi. Chrome Platform Status liste les boîtes de marge @page à partir du jalon 131, donc les recommandations écrites avant cela reflètent un comportement historique. Sur Chrome 153, cette seule règle de compteur de page a numéroté chaque page d’un document de quatre pages :

@page { @bottom-center { content: "Page " counter(page); } }
CSS

Contrôler l’emplacement d’un saut de page se fait aussi en CSS classique. Un document test de six cartes a montré la différence. Sans la propriété, la première page se terminait à mi-chemin de la troisième carte, et le reste de cette carte continuait sur la page deux. L’ajout de la propriété CSS break-inside a déplacé chaque carte entière sur la page suivante, deux par page, sans aucune coupée :

.card { break-inside: avoid; }
CSS

Ce que Chrome met dans le PDF

Deux options modifient la structure du fichier, et non l’apparence de la page :

let options = PrintToPdfOptions {
    generate_document_outline: Some(true),
    generate_tagged_pdf: Some(true),
    ..Default::default()
};
Rust

generate_document_outline transforme vos titres en signets PDF. Un rapport avec un h1 et deux titres h2 a produit une table des matières à trois entrées avec l’option activée, et aucune table des matières avec l’option désactivée.

generate_tagged_pdf demande un PDF balisé, la structure que les lecteurs d’écran et les vérificateurs PDF/UA lisent. La documentation du DevTools Protocol indique que sa valeur par défaut est « embedder choice » au lieu de désactivé, et le test ici a confirmé cela. Avec les deux options désactivées, la sortie contenait tout de même un arbre de structure et transportait la langue du document depuis <html lang="en">. Définissez cet attribut dans vos modèles dans tous les cas, et vérifiez votre propre sortie avant de vous fier à ce paramètre.

Les polices sont intégrées avec sous-ensemble de polices, donc une page en Georgia a produit AAAAAA+Georgia-Bold et BAAAAA+Georgia au lieu de toute la famille. Une photographie JPEG a été stockée en JPEG, sans ré-encodage.

Utilisation de Chrome Headless dans un service Rust

Le crate est bloquant, c’est pourquoi aucun des exemples ci-dessus n’est écrit comme un async fn main. Si votre service utilise déjà un runtime asynchrone comme Tokio, gardez le navigateur hors du réacteur en l’appelant à l’intérieur de tokio::task::spawn_blocking, afin qu’un rendu lent ne bloque pas l’exécuteur.

Rien n’interroge indéfiniment. Chaque opération d’onglet s’exécute avec un délai d’expiration et retourne une erreur au lieu de rester bloquée, donc une page qui ne se stabilise jamais ne peut pas monopoliser un worker.

Les lignes de démarrage et d’arrêt de Chrome apparaissent dans tout service qui installe un logger, car le crate rapporte via le crate log. Pour supprimer les logs de la couche navigateur sans couper les vôtres, filtrez par cible, par exemple RUST_LOG=info,headless_chrome=warn.

Problèmes courants lors de la conversion HTML en PDF en Rust

Voici les modes d’échec rencontrés en production :

  • Contenu généré par JavaScript : wait_until_navigated retourne une fois que le réseau devient silencieux, ce qui n’est pas la même chose qu’un graphique ayant fini de se dessiner. Appelez tab.wait_for_element("#report-ready") sur un élément que la page ajoute lorsqu’elle a terminé, puis imprimez.
  • Timeouts : les opérations d’onglet expirent après 20 secondes par défaut. Augmentez la limite avec tab.set_default_timeout(std::time::Duration::from_secs(60)) pour les pages lentes.
  • Grandes chaînes HTML : Chrome limite les URLs à 2 Mo, ce qui inclut les URLs data:. Pour les documents plus volumineux, écrivez le HTML dans un fichier temporaire et chargez-le avec une URL file:// comme montré ci-dessus.
  • Docker et conteneurs Linux : Le sandbox de Chrome échoue à démarrer lorsque le processus s’exécute en tant que root, et le guide de dépannage de Puppeteer déconseille fortement de désactiver le sandbox. Ajoutez un utilisateur non privilégié à l’image et gardez le sandbox activé, et définissez sandbox: false dans LaunchOptions uniquement si vous n’avez pas d’alternative. Dans tous les cas, l’image a besoin des bibliothèques système de Chrome.
  • Déploiement : chaque serveur qui exécute le programme a besoin d’un navigateur compatible, donc Chrome fait partie de votre déploiement même si le code Rust compile en un seul binaire.

Autres moyens de convertir du HTML en PDF en Rust

headless_chrome n’est pas la seule solution. Le choix dépend de la nécessité ou non de JavaScript dans vos documents et du nombre de rendus simultanés.

Basé sur Chromium, comme ce tutoriel

html2pdf se présente comme une simple CLI au-dessus du crate headless_chrome, et il est également fourni comme bibliothèque dont l’API est asynchrone et fonctionne sur tokio, ce qui vous évite d’écrire vous-même le wrapper spawn_blocking.

Gotenberg déplace complètement le navigateur hors de votre processus. Il s’agit d’une API basée sur Docker pour convertir des documents en PDF : Chromium gère les URLs, HTML et Markdown, LibreOffice gère les formats bureautiques, et votre service Rust envoie un fichier via HTTP et reçoit un PDF en retour. Cela permet d’exclure Chrome du déploiement de votre binaire au prix de l’exécution d’un service à côté.

Moteurs Rust sans navigateur

Headless Chrome peut être gourmand en ressources pour la génération simultanée de PDF, car chaque conversion nécessite un processus navigateur et la mémoire qui l’accompagne. Deux projets Rust ciblent directement ce problème.

htmltopdf est un moteur sous licence MIT qui effectue le rendu dans un seul thread sans sous-processus, et son README le décrit comme conçu pour une forte concurrence et une faible utilisation de la RAM. Le README indique environ 92 Mo de RAM maximale contre environ 846 Mo pour le processus principal de Chromium sur un seul document de 1,8 Mo. Pour 20 conversions simultanées, il annonce 12,75 PDF/s à 1,25 Gio contre 1,18 PDF/s à 9,35 Gio pour Chromium, mesuré avec /usr/bin/time -l sur Apple Silicon. Ce sont les propres benchmarks du projet sur ses propres jeux de tests, et ils n'ont pas été reproduits pour cet article. Le crate n’est pas sur crates.io, il faut donc l’installer depuis le dépôt, et la gestion du JavaScript est une étape préliminaire optionnelle et limitée, pas un moteur complet.

Fulgur est un autre moteur HTML vers PDF en Rust qui se passe du navigateur. Il est sous licence Apache-2.0, et il intègre Blitz pour l’analyse HTML, la résolution des styles et la mise en page avec Krilla pour la génération de PDF. Fulgur prend en charge un sous-ensemble sélectionné de HTML et CSS, suivi propriété par propriété dans son document de support CSS, et sa liste de fonctionnalités n’inclut pas de moteur JavaScript. Ce qu’il couvre, c’est la partie paginée, incluant les compteurs de pages, les en-têtes courants, les boîtes de marges, break-inside, les PDF balisés et la sous-sélection des polices. Le pipeline de rendu de Fulgur inclut un rendu en deux passes pour plus de précision, de sorte que les références croisées telles que target-counter() sont résolues avant l’écriture du PDF.

Moteurs commerciaux

Prince prend en charge CSS Paged Media pour la création de PDF complexes, y compris les règles @page, les boîtes de marges de page et un compteur de pages prédéfini pour les en-têtes et pieds de page courants. Prince est un logiciel commercial sous licence, et non un crate à ajouter avec Cargo.

Lequel choisir

Pendant des années, la règle empirique était que les options HTML vers PDF natives Rust avaient un support limité de CSS et JavaScript, donc les moteurs purement Rust ne convenaient qu’aux documents simples. Cette partie CSS a évolué. htmltopdf liste flexbox, grid, tableaux avec rowspans et @font-face, et Fulgur couvre les médias paginés de bout en bout. Le JavaScript reste le point faible.

C’est le mode de génération de votre document qui détermine le choix. Si un serveur génère le HTML et que le style est en CSS, un moteur sans navigateur retire Chrome de votre déploiement ainsi que sa mémoire. Si vos pages dessinent des graphiques dans le navigateur ou dépendent des scripts d’une application web, gardez un navigateur dans la chaîne, ce que fait ce tutoriel.

IronPDF pour Rust (Bientôt disponible)

IronPDF pour Rust est en cours de développement. La bibliothèque prévue permettra de créer des PDF à partir de HTML et de manipuler des PDF existants, le tout depuis du code Rust.

Rejoignez le programme bêta IronPDF pour Rust pour accéder en avant-première et contribuer à façonner l’API.

Fichier HTML vers fichier PDF en C#

IronPDF

IronPDF HTML-to-PDF Conversion Library est une bibliothèque C# pour .NET et .NET Core qui génère des documents PDF à partir de contenu HTML. Elle embarque son propre moteur de rendu Chrome, il n’y a donc pas de navigateur séparé à installer, lancer ou arrêter.

IronPDF gère bien plus que de simples documents HTML. Il rend des pages web complexes avec du style CSS et du JavaScript, et il permet aussi d’éditer, fusionner, signer et sécuriser les PDF après leur création.

Le même travail avec IronPDF, convertir une chaîne HTML en PDF en C# :

using IronPdf;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create PDF content from an HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

Le résultat PDF :

Comment convertir du HTML en PDF en Rust : Figure 6 - Résultat IronPDF

Les étapes de ce tutoriel Rust correspondent à des paramètres IronPDF uniques. La configuration de la page est couverte dans marges personnalisées et taille de papier personnalisée, et le problème d’attente du JavaScript est géré par les délais de rendu WaitFor. Convertir une URL en PDF ou un fichier HTML en PDF se fait en un seul appel de méthode, et en-têtes et pieds de page avec numéros de page ne nécessitent aucun modèle HTML. Pour un guide complet, consultez le tutoriel HTML vers PDF, ou lisez comment la même tâche fonctionne dans HTML vers PDF en C++.

Vous pouvez essayer tout cela avec une version d’essai gratuite de toutes les fonctionnalités d’IronPDF. Elle fonctionne pendant 30 jours, ne nécessite pas de carte bancaire, et fonctionne sur des serveurs en production sans filigrane pendant votre évaluation. La licence ensuite est perpétuelle, sans frais récurrents, dimensionnée par développeurs, projets et emplacements, et accompagnée d’une garantie de remboursement de 30 jours. Pour commencer, téléchargez IronPDF.

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 et créer des manuels bien structurés et visuellement attrayants.

Lire la suite

Articles connexes