Architecture économe en énergie

1) Principes de base

1. Energy as a First-Class Metric. Joulie/demande, W/noyau, kWh/TB-mois - les mêmes KPI que p95 et le coût.
2. Carbon-/Energy-Aware Orchestration. Le calendrier de charge et le placement des tâches tiennent compte de l'intensité CO₂ du réseau et des centres de données.
3. Data Minimization. Moins de données → moins de CPU/IO → moins d'énergie et de refroidissement.
4. Right-sizing & Right-placing. Nous choisissons le type et la taille corrects de la ressource et nous placons plus près de l'utilisateur/des données.
5. Simplicity Wins. Abstraction et chateté supplémentaires = énergie supplémentaire.

2) Métriques et modèles

2. 1 Infrastructures

PUE (Power Utilisation Effectiveness) : 'PUE = Énergie totale du centre de données/énergie de la charge informatique' (plus il est proche de 1 - mieux c'est).
CUE (Carbon Usage Effectiveness) : 'CUE = CO₂e/Énergie IT'.
WUE (Water UE) : Les litres d'eau par kWh sont importants pour les régions en pénurie d'eau.

2. 2 Applications

J/req (joules à la demande) : "E _ req = ∫ P (t) dt/ N_req'.
kWh/ETL-jobu, kWh/millions de messages, kWh/formation de modèle.
SO₂e/ficha ou SO₂e/polzovatel : 'CO₂e = kWh × grid_factor (heure, région)'.

2. 3 Modèle carbone

carbon(req) = energy(req) grid_emission_factor(region, time)
energy(req) = cpu_j + mem_j + io_j + net_j

Où 'grid _ emission _ factor' change selon l'heure et la région (planification au carbone).

3) Équipement et niveau d'exécution

Architectures CPU : ARM/Graviton/RISC-V donnent souvent le meilleur « W/perf » pour les charges réseau et Java/Go ; x86 reste fort pour les tactiques hautes et certains SIMD.
GPU/TPU/autres accélérateurs : sur l'analyse ML/vectorielle, on donne souvent le meilleur « J/opération » si l'on tape et que l'on conserve un recyclage élevé.
DVFS et power capping : abaissement dynamique de la fréquence et limitation du TDP à des tâches non critiques.
Mode veille/auto-extinction : politiques agressives 'idle' pour les workers et les arrière-plans.
Mémoire : La localisation NUMA et la réduction des erreurs de page réduisent la consommation d'énergie des pneus et des cases.

4) Modèles architecturaux

4. 1 Microservices sans « chats »

Raccourcis RPC : passerelles d'agrégation, endpoints composites.
gRPC/HTTP/2/3 au lieu d'un REST chatté.
Batch + Async : collez les petites opérations.

4. 2 Voies « chaudes » et « froides »

Pour les demandes rares et lourdes, l'infrastructure non sécurisée (on-demand, fonctions/serveurs).
Les chemins chauds sont des connexions et des pools qui vivent longtemps.

4. 3 Mise en cache avec coalescing

Les requêtes de coalescing évitent les tempêtes d'erreurs de cache.
Stale-while-revalidate : nous donnons l'obsolète, nous économisons la randonnée à la source.

4. 4 Tiring de stockage

Hot/Warm/Cold/Archive : NVMe → SSD → objet retardé → glacier.
ILM/TTL automatique : moins de spins/IO → moins d'énergie.

4. 5 Planificateur au carbone (Carbon-Aware)

Les jobs temporels (ETL, analyse, entraînement) sont des horloges/régions « vertes ».
Egress routes régionales par kWh et CO₂ - agrégez localement.

python def schedule(job):
windows = get_green_windows(job.region_candidates, next_48h)
pick = argmin(windows, key=lambda w: w.grid_factor job.energy_estimate / w.capacity)
enqueue(job, region=pick.region, start=pick.start)

4. 6 Déduplication et compression « intelligente »

La compression permet d'économiser le réseau/disque, mais coûte CPU. Appliquez de manière adaptative : charges utiles importantes, circuit CPU bas.

5) Efficacité du code et des données

Algorithme : réduire l'asymptotique> tuning. Profilez les « points chauds ».
Allocation de mémoire : location de tampons, pools d'objets - moins de GC/énergie.
Formats : protocoles binaires, formats de colonne (Parquet/ORC) pour l'analyse, distribution de clés zipf à prendre en compte lors de la mise en cache.
I/O : packaging, vectorisation, entrée/sortie asynchrone.
Streaming vs scans complets : filtres push-down à la source de données.
Fonctions sur le bord (edge) : pré-agrégation, rejet des événements sonores.

E_req ≈ (cpu_ms W_cpu/ms) + (mem_ms W_mem/ms) +
(io_read_mb W_io/mb + io_write_mb W_io/mb) +
(egress_mb W_net/mb)

6) ML et données : modèles d'énergie

Architecture des modèles : petits modèles spécialisés, distillation, quantification (int8/4-bit), sparsity.
Formation : taille batch ↗ recyclage, préparation mixte (FP16/BF16), chekpoints, arrêt précoce.
Inference : batch + microbatches, compilation (TensorRT/ONNX Runtime), serveur triton avec dinam. Batching.
Fichi et Figh Store : mise en cache des fiches fréquemment utilisées, dégradation de la qualité au lieu de surcharger l'origine.

7) Réseau et protocoles

Keep-alive, HTTP/3, QUIC, minimisation du handshake.
CDN + edge-cashi : les itinéraires sont plus courts → moins de kWh.
Compression avec profil : zstd/brottis pour les grandes ressources, pas de compression pour les petites voies/CPU coûteuses.
Duplication multirégionale - uniquement si le RTO/RPO est réellement nécessaire.

8) Télémétrie et « energo-observabilité »

8. 1 Collecte

Compteurs d'énergie/puissance (IPMI/RAPL/Node Exporter Power), télémétrie GPU/TPU.
Au niveau de l'application : attribution J/req - par sample de temps CPU/IO et coefficients d'étalonnage.
Corrélation avec les traces : 'energy _ j', 'carbon _ g', 'grid _ factor', 'region'.

8. 2 Métriques et alertes

Energy per SLI: `J/p95`, `J/txn`.
Budget carbone : limites mensuelles CO₂e par produit.
Drift : croissance 'J/req'> X % de la basline.

9) CI/CD, gates et tests

Perf-smoke + Energy-smoke sur PR : scénario court, collection « J/req » et gate de régression.
Baslines d'énergie : nous stockons la référence (flûtes CPU/GPU, J/req).
Policy as Code : Interdit le dépliage si 'Δ J/req> 10 %' sans exception approuvée.
Chaos + modèles énergétiques : la dégradation des dépendances ne devrait pas augmenter J/req au-delà des limites (shading/dégradation au lieu de rétro-tempêtes).

10) Gestion de la charge et du temps

Décalage temporel (load shifting) : les tâches non interactives sont en horloge verte.
SLO dynamique : pour les fonds, vous pouvez augmenter la latence pour économiser de l'énergie.
Priorité : les demandes critiques reçoivent des « quotas énergétiques », la priorité faible est reportée.

python if energy_budget.low() and req.priority == "low":
return 429_DEFER process(req)

11) Sécurité, vie privée et conformité

Cryptage avec accélération matérielle (AES-NI/ARMv8 Crypto) - moins de CPU/W.
La minimisation des PII réduit la charge de stockage/analyse.
Logs : échantillonnage, masquage et TTL - économise l'énergie de collecte/stockage.

12) Anti-modèles

Microservices excessifs et « chats » entre les services.
Réplication globale au cas où.
Cache TTL zéro et interdiction stale.
Scans complets sans filtres/index/lots.
Des rétractions permanentes sans jitter → des tempêtes en réseau.
L'utilisation d'un « grand modèle » là où l'heuristique suffit.
Formats de logs lourds et « tout est logé pour toujours ».

13) Mini recettes et exemples

13. 1 Compression adaptative de réponse

python def maybe_compress(resp, cpu_load, size):
if size > 641024 and cpu_load < 0.6:
return compress_zstd(resp, level=5)
return resp # мелкие/дорогие по CPU ответы не сжимаем

13. 2 Heuristique de Batch Inference

python batch = collect_until(max_items=64, max_wait_ms=8)
result = model.infer(batch) # ↑ утилизация ускорителя, ↓ Дж/запрос

13. 3 ILM/TTL pour les événements

yaml dataset: events lifecycle:
- hot: 7d  # NVMe
- warm: 90d # SSD + zstd
- cold: 365d # object store
- delete

13. 4 ETL au carbone

python co2 = kwh_estimate(job) grid_factor(region, now())
if co2 > job.threshold and job.deferable:
delay(job, until=next_green_window())
else:
run(job)

14) Chèque de l'architecte

1. Défini par SLI pour l'énergie (J/req, kWh/jobu) et le carbone (gCO₂e/req) ?
2. Existe-t-il un modèle d'attribution de l'énergie par services/fiches/tenants ?
3. Un planificateur compétent en carbone pour les tâches transférables a-t-il été mis en œuvre ?
4. Les microservices minimisent-ils le chatovity (agrégation, batchi, gRPC/HTTP3) ?
5. Les caches avec coalescing et mode stale-while-revalidate sont-ils configurés ?
6. Les entrepôts sont-ils teints, ILM/TTL inclus, les formats de données sont-ils optimaux ?
7. ML : Distillation/Quantification/Batching/Compilation Inference utilisé ?
8. Y a-t-il dans CI/CD de l'énergie-smoke, des bazlines et des gates sur le Δ J/req ?
9. Edge/CDN/hébergement régional minimise egress et itinéraires ?
10. Activé DVFS/power-capping/idle pour les workers ?
11. Les logs/métriques/trajets sont-ils semplés et ont une rétention d'importance ?
12. Runbook « vert » documenté : qu'éteindre/dégrader en cas de pénurie d'énergie ?

Conclusion

L'architecture économe en énergie n'est pas une « dernière optimisation », mais une couche stratégique de qualité : des algorithmes et des formats à la mise en place dans la région « verte » et aux gates dans CI/CD. Mesurez les joules, planifiez en fonction du carbone, simplifiez les interactions, fondez les données et utilisez les accélérateurs là où cela réduit « J/opération ». Ainsi, vous obtiendrez une plate-forme plus rapide, moins chère et plus écologique - sans compromis sur la valeur alimentaire.