Génération d'HTML API sur le serveur sans rendu

Générer du HTML comme une API : un serveur qui retourne du texte brut

Créer un service web côté serveur est simple : répondre aux requêtes HTTP avec du texte brut au format HTML. Cette approche fondamentale et fiable ne nécessite aucune dépendance supplémentaire. Le navigateur s'occupe de toute la complexité du rendu automatiquement.

Voici un serveur Python minimal utilisant le module intégré http.server. Il renvoie une page HTML statique pour toute requête GET :

from http.server import BaseHTTPRequestHandler, HTTPServer

WEBPAGE = "<h1>Page web en Python !</h1>\n"

class HTMLServer(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write(str.encode(WEBPAGE))

webServer = HTTPServer(("localhost", 8080), HTMLServer)
print("Serveur en cours d'exécution à http://localhost:8080")
webServer.serve_forever()

Avec curl, vous obtenez du texte propre et brut :

$ curl localhost:8080
<h1>Page web en Python !</h1>

Dans le navigateur, la balise <h1> s'affiche comme un titre formaté. Ajoutez du CSS pour styliser :

WEBPAGE = """
<style>
body {
  background-color: lightblue;
  font-family: 'Comic Sans MS', cursive;
}
</style>
<h1>Page web en Python !</h1>
"""

Le navigateur applique les styles instantanément — aucune étape supplémentaire nécessaire.

Le rendu, c’est le travail du navigateur

Le serveur génère du texte ; le navigateur le parse en DOM, calcule les styles, détermine la mise en page et applique les polices avec une gestion correcte de la DPI, de l’espacement et des métriques. Ce processus en plusieurs étapes inclut le parsing, le calcul des styles, la mise en page et le dessin.

Le rendu exige une connaissance approfondie de la typographie — de la conversion des points en pixels à la gestion des hauteurs des ascenseurs et descenders. Les navigateurs gèrent toute cette complexité pour vous.

La génération de HTML n’est qu’une manipulation de chaînes de caractères. Pas besoin de jargon comme « rendu côté serveur » qui suggère une complexité inutile.

Utiliser le HTML pour représenter des données

Toute donnée peut être exprimée en HTML via des modèles simples de chaînes. Voici un exemple avec les arrondissements de New York :

boroughs = [
  "Le Bronx",
  "Manhattan",
  "Brooklyn",
  "Queens",
  "Île de Staten"
]

LIST = "<li>".join(boroughs)
WEBPAGE = "<h1>Arrondissements de NYC</h1><ul><li>" + LIST + "</ul>"

Le navigateur interprète correctement ce code — même sans fermer les balises </li> (HTML5 est tolérant).

De même, pour JSON :

LIST = '","'.join(boroughs)
WEBPAGE = '{ "nyc_boroughs": ["' + LIST + '"] }'

Ici, le HTML l'emporte : il intègre nativement des fonctionnalités d'hypermédia — liens, formulaires — sans nécessiter de JavaScript côté client.

• Avantages de la génération de HTML par chaînes :

- Fonctionne dans n'importe quel langage sans bibliothèque.

- Faible surcharge.

- Facile à déboguer : curl affiche la sortie brute.

- Compatibilité multiplateforme (bash, awk, Python).

Une API HTML plutôt qu'une API JSON

Appelez-la une API HTML : le serveur renvoie du HTML au lieu de JSON. Le navigateur agit comme client, interprétant l'hypermédia.

Comparez :

HTML :

<h1>Arrondissements de NYC</h1>
<ul>
  <li>Le Bronx
  <li>Manhattan
  <li>Brooklyn
  <li>Queens
  <li>Île de Staten
</ul>

JSON :

{
  "nyc_boroughs": [
    "Le Bronx",
    "Manhattan",
    "Brooklyn",
    "Queens",
    "Île de Staten"
  ]
}

Le HTML intègre à la fois les données et la présentation. Le JSON fournit uniquement les données — nécessitant une logique côté client pour les afficher.

Moteurs de templates pour production

Pour des services réels, utilisez des moteurs de templates comme Jinja2. Ils offrent l’échappement automatique, les boucles, l’héritage et une structure claire.

Exemple avec Jinja :

<h1>Arrondissements de NYC</h1>
<ul>
  {% for borough in boroughs %}
  <li>{{ borough }}
  {% endfor %}
</ul>

• Principaux avantages des moteurs de templates :

1. Échappement automatique du HTML pour éviter les attaques XSS.

2. Fragments réutilisables (partials).

3. Syntaxe native pour votre langage (Htmx pour Rust, Zig).

4. Conception sans état — facile à tester et à déboguer.

5. Aucun surcoût d’hydratation comme dans les SPAs.

Contrairement à React, où le JSON est hydraté en DOM côté client, les templates génèrent du HTML entièrement rendu côté serveur.

Ce qui compte vraiment

• Le serveur produit du texte HTML — le navigateur s'occupe du rendu.
• Une API HTML transmet de l'hypermédia, pas des données brutes JSON.
• Les opérations sur chaînes fonctionnent partout, sans framework.
• Les moteurs de templates ajoutent sécurité et structure.
• Cette approche s'échelonne à n'importe quel langage de programmation.

— Editorial Team