Mesurer : EcoIndex, Lighthouse et calculateurs carbone

Mesurer l'impact d'un service numérique, c'est relever des grandeurs observables (poids d'une page, nombre de requêtes, taille du DOM, consommation électrique) puis, si besoin, les convertir en score ou en estimation d'émissions grâce à un modèle. L'EcoIndex, GreenIT-Analysis, Lighthouse et les calculateurs carbone sont les outils les plus utilisés. Ce chapitre explique ce que chacun mesure vraiment, comment monter un protocole de mesure fiable, comment l'EcoIndex calcule sa note, et les limites à connaître avant de citer un chiffre.

Mesurer, estimer, évaluer

Trois niveaux de précision existent, et il faut savoir sur lequel on se trouve.

Les outils de mesure d'une page web

Les outils de développement du navigateur. C'est la mesure de base, sans rien installer. L'onglet Réseau donne le nombre de requêtes, le poids transféré et le poids décompressé, ressource par ressource, avec un filtre par type et par domaine. La console compte les éléments du DOM : document.querySelectorAll('*').length.

Lighthouse. Intégré aux outils de développement de Chrome (onglet Lighthouse), il audite une page et la note sur quatre catégories : performance, accessibilité, bonnes pratiques et référencement. Depuis la version 13, sortie en octobre 2025, ses conseils de performance sont regroupés en « insights » : diffusion des images, cache, ressources qui bloquent l'affichage, scripts en double, services tiers. Lighthouse ne mesure pas l'impact environnemental, mais une page rapide sur un téléphone d'entrée de gamme est presque toujours une page sobre. Il mesure aussi deux des trois Core Web Vitals, les indicateurs de Google : LCP (affichage du plus grand élément, bon sous 2,5 s) et CLS (stabilité de la mise en page, bon sous 0,1). Le troisième, l'INP (réactivité aux interactions, bon sous 200 ms), suppose de vraies interactions : Lighthouse l'approche par le TBT (temps de blocage total), et PageSpeed Insights affiche l'INP mesuré chez les vrais utilisateurs de Chrome (les Core Web Vitals).

L'EcoIndex et GreenIT-Analysis. Né au sein du collectif GreenIT.fr, l'EcoIndex est un projet libre, maintenu par le Collectif Conception Numérique Responsable. Le site ecoindex.fr analyse une page publique à partir de son adresse. L'extension GreenIT-Analysis, pour Chrome et Firefox, calcule l'EcoIndex d'une page ouverte dans ton navigateur, y compris une page interne ou derrière une connexion, et vérifie une liste de bonnes pratiques d'écoconception (images redimensionnées, cache, compression, polices, requêtes en erreur…).

Les calculateurs carbone. Website Carbon estime les émissions d'un chargement de page à partir de son poids et de l'hébergeur ; depuis le 14 juillet 2025, il utilise la version 4 du Sustainable Web Design Model, dont les estimations sont en moyenne deux tiers plus basses que celles de la version 3, ce qui montre à quel point le résultat dépend du modèle. La bibliothèque libre CO2.js fait le même calcul dans ton propre code. Impact CO₂, le site de l'ADEME, donne l'empreinte de référence des appareils et des usages courants (ordinateur, smartphone, vidéo, visioconférence). Boavizta, un groupe de travail inter-organisations, publie une API libre qui estime l'empreinte multicritère d'un serveur ou d'une instance cloud selon sa configuration.

La consommation électrique des serveurs. Un wattmètre entre la prise et la machine donne la mesure la plus simple. Les serveurs récents exposent aussi leur consommation par leur carte de gestion (IPMI ou Redfish), que Zabbix sait relever et suivre dans le temps (ce qu'il faut superviser).

Un protocole de mesure fiable

Une mesure isolée ne vaut rien ; un protocole rend les chiffres comparables et défendables devant un jury.

1. Choisis les parcours qui comptent, comme le RGESN le demande pour la déclaration : pour Sorbier, « suivre un colis » = page d'accueil, saisie du numéro, page de résultat.
2. Fixe les conditions : même navigateur, fenêtre de navigation privée sans extensions (sauf l'outil de mesure), cache désactivé pour une première visite, même bridage du réseau.
3. Mesure trois fois et garde la valeur médiane, car le réseau et les services tiers varient d'un chargement à l'autre.
4. Note tout : date, adresse, outil et sa version, valeurs.
5. Agis, puis mesure à nouveau dans les mêmes conditions, et documente le gain.

Pour t'entraîner sur une application complète, mesure les écrans du TP AppliFrais avant et après tes optimisations : c'est exactement le genre de preuve qu'une commission d'E6 apprécie.

Comment l'EcoIndex calcule sa note

L'EcoIndex part de trois mesures, chacune associée à un maillon du numérique :

• la taille du DOM (nombre d'éléments), pour le terminal ;
• le nombre de requêtes, pour le serveur et les centres de données ;
• le poids transféré, pour le réseau.

Chaque mesure est placée sur une échelle de 0 à 20 (un quantile) en la comparant à un grand échantillon de pages réelles issu de l'HTTP Archive. La note combine les trois positions avec des poids 3, 2 et 1 : le DOM compte triple, parce que le terminal, surtout sa fabrication, concentre l'essentiel de l'impact.

EcoIndex = 100 − 5 × (3 × qDOM + 2 × qrequêtes + 1 × qpoids) / 6

Le score va de 0 à 100 ; plus il est haut, mieux c'est. Il se traduit en lettre selon des seuils, et en estimations de gaz à effet de serre et d'eau par vue, calculées autour d'une moyenne de 2 g CO₂e et 3 cl d'eau pour une page de score 50.

Ce petit programme reproduit le calcul de référence, avec les bornes publiées dans le dépôt libre du projet (cnumr/ecoindex_python_fullstack). Il n'utilise que Python, sans bibliothèque :

# ecoindex.py : calcule l'EcoIndex d'une page à partir de ses trois mesures.
# Quantiles et seuils repris de l'implémentation de référence (dépôt cnumr/ecoindex_python_fullstack).

QUANTILES_DOM = [0, 47, 75, 159, 233, 298, 358, 417, 476, 537, 603, 674, 753,
                 843, 949, 1076, 1237, 1459, 1801, 2479, 594601]
QUANTILES_REQUETES = [0, 2, 15, 25, 34, 42, 49, 56, 63, 70, 78, 86, 95, 105,
                      117, 130, 147, 170, 205, 281, 3920]
QUANTILES_POIDS_KO = [0, 1.37, 144.7, 319.53, 479.46, 631.97, 783.38, 937.91,
                      1098.62, 1265.47, 1448.32, 1648.27, 1876.08, 2142.06,
                      2465.37, 2866.31, 3401.59, 4155.73, 5400.08, 8037.54,
                      223212.26]
SEUILS = [("A", 80), ("B", 70), ("C", 55), ("D", 40), ("E", 25), ("F", 10)]


def quantile(bornes, valeur):
    """Position de la valeur entre 0 et 20, interpolée entre deux bornes."""
    for i in range(1, len(bornes)):
        if valeur < bornes[i]:
            return i - 1 + (valeur - bornes[i - 1]) / (bornes[i] - bornes[i - 1])
    return len(bornes) - 1


def ecoindex(elements_dom, requetes, poids_ko):
    q_dom = quantile(QUANTILES_DOM, elements_dom)
    q_req = quantile(QUANTILES_REQUETES, requetes)
    q_poids = quantile(QUANTILES_POIDS_KO, poids_ko)
    return round(100 - 5 * (3 * q_dom + 2 * q_req + q_poids) / 6)


def note(score):
    for lettre, seuil in SEUILS:
        if score > seuil:
            return lettre
    return "G"


def ges_g(score):
    return round(2 + 2 * (50 - score) / 100, 2)


def eau_cl(score):
    return round(3 + 3 * (50 - score) / 100, 2)


if __name__ == "__main__":
    for nom, dom, req, ko in [("avant", 1450, 112, 4180), ("après", 610, 28, 690)]:
        score = ecoindex(dom, req, ko)
        print(f"{nom} : EcoIndex {score}, note {note(score)}, "
              f"{ges_g(score)} g CO2e et {eau_cl(score)} cl d'eau par vue")

$ python3 ecoindex.py
avant : EcoIndex 21, note F, 2.58 g CO2e et 3.87 cl d'eau par vue
après : EcoIndex 65, note C, 1.7 g CO2e et 2.55 cl d'eau par vue

Tu retrouves le gain de la page de suivi du chapitre 4 : de 21 (F) à 65 (C).

Les limites des scores

Un score est un indicateur, pas une vérité. Garde ces limites en tête avant de le citer.

• L'échelle est relative. L'EcoIndex compare ta page aux pages du web : une note A signifie « parmi les plus sobres de l'échantillon », pas « sans impact ».
• Seul le chargement est mesuré. Ce que fait l'utilisateur ensuite (défiler, regarder une vidéo pendant vingt minutes, laisser un onglet interroger le serveur toutes les cinq secondes) n'apparaît pas.
• Le travail du serveur est invisible. Une page légère peut cacher une requête SQL de dix secondes ou un modèle d'IA appelé à chaque visite.
• Le JavaScript est sous-estimé. Le DOM et le poids ne disent pas combien de temps le processeur passe à exécuter les scripts ; Lighthouse le voit mieux.
• On peut tricher. Différer le chargement de tout après la mesure améliore la note sans réduire ce que l'utilisateur télécharge vraiment.

Exercices