Développer des logiciels économes en énergie

Last reviewed 2026-01-28 UTC

Ce principe du pilier de durabilité du Google Cloud Well-Architected Framework fournit des recommandations pour écrire des logiciels qui minimisent la consommation d'énergie et la charge du serveur.

Présentation des principes

En suivant les bonnes pratiques pour créer vos applications cloud, vous optimisez l'énergie utilisée par les ressources d'infrastructure cloud : IA, calcul, stockage et réseau. Vous contribuez également à réduire les besoins en eau des centres de données et l'énergie consommée par les appareils des utilisateurs finaux lorsqu'ils accèdent à vos applications.

Pour créer des logiciels économes en énergie, vous devez intégrer des considérations de durabilité tout au long du cycle de vie du logiciel, de la conception et du développement au déploiement, à la maintenance et à l'archivage. Pour obtenir des conseils détaillés sur l'utilisation de l'IA pour créer des logiciels qui minimisent l'impact environnemental des charges de travail cloud, consultez l'e-book Google Cloud , Développer des logiciels de manière durable.

Recommandations

Les recommandations de cette section sont regroupées dans les domaines d'action suivants :

Réduire le travail de calcul

Pour écrire un logiciel économe en énergie, vous devez minimiser la quantité totale de travail de calcul effectué par votre application. Chaque instruction inutile, boucle redondante et fonctionnalité supplémentaire consomment de l'énergie, du temps et des ressources. Suivez les recommandations ci-dessous pour créer un logiciel qui effectue un minimum de calculs.

Écrire du code simple et ciblé

Pour écrire le minimum de code essentiel pour obtenir les résultats souhaités, utilisez les approches suivantes :

  • Éliminez la logique redondante et les fonctionnalités inutiles : écrivez du code qui n'exécute que les fonctions essentielles. Évitez les fonctionnalités qui augmentent la surcharge et la complexité de calcul, mais qui n'apportent pas de valeur mesurable à vos utilisateurs.
  • Refactoriser : pour améliorer l'efficacité énergétique au fil du temps, auditez régulièrement vos applications afin d'identifier les fonctionnalités inutilisées. Prenez les mesures nécessaires pour supprimer ou refactoriser ces fonctionnalités, selon le cas.
  • Évitez les opérations inutiles : ne calculez pas de valeur ni n'exécutez d'action tant que le résultat n'est pas nécessaire. Utilisez des techniques telles que l'évaluation différée, qui retarde les calculs jusqu'à ce qu'un composant dépendant de l'application ait besoin du résultat.
  • Privilégiez la lisibilité et la réutilisabilité du code : écrivez du code lisible et réutilisable. Cette approche minimise la duplication et suit le principe DRY (Don't Repeat Yourself), qui peut aider à réduire les émissions de carbone liées au développement et à la maintenance des logiciels.

Utiliser la mise en cache du backend

La mise en cache du backend permet à une application de ne pas effectuer la même tâche à plusieurs reprises. Un taux d'accès au cache élevé entraîne une réduction presque linéaire de la consommation d'énergie par requête. Pour implémenter la mise en cache du backend, utilisez les techniques suivantes :

  • Mettre en cache les données fréquentes : stockez les données fréquemment consultées dans un emplacement de stockage temporaire et performant. Par exemple, utilisez un service de mise en cache en mémoire comme Memorystore. Lorsqu'une application récupère des données à partir d'un cache, le volume de requêtes de base de données et d'opérations d'E/S de disque est réduit. Par conséquent, la charge sur les bases de données et les serveurs du backend diminue.
  • Mettre en cache les réponses de l'API : pour éviter les appels réseau redondants et coûteux, mettez en cache les résultats des requêtes d'API fréquentes.
  • Priorisez la mise en cache en mémoire : pour éliminer les opérations d'E/S sur disque lentes et les requêtes de base de données complexes, stockez les données dans une mémoire vive (RAM) à haute vitesse.
  • Sélectionnez les stratégies d'écriture du cache appropriées.
    • La stratégie d'écriture différée garantit que les données sont écrites de manière synchrone dans le cache et le stockage persistant. Cette stratégie augmente la probabilité d'accès au cache, de sorte que le stockage persistant reçoit moins de requêtes de lecture énergivores.
    • La stratégie d'écriture différée (write-behind) améliore les performances des applications qui effectuent de nombreuses opérations d'écriture. Les données sont d'abord écrites dans le cache, puis la base de données est mise à jour de manière asynchrone ultérieurement. Cette stratégie réduit la charge d'écriture immédiate sur les bases de données plus lentes.
  • Utilisez des règles d'éviction intelligentes : maintenez le cache léger et efficace. Pour supprimer les données obsolètes ou peu utiles et maximiser l'espace disponible pour les données fréquemment demandées, utilisez des règles telles que la valeur TTL (Time To Live), les données les moins récemment utilisées (LRU) et les données les moins fréquemment utilisées (LFU).

Utiliser des algorithmes et des structures de données efficaces

Les algorithmes et les structures de données que vous choisissez déterminent la complexité de calcul brute de votre logiciel. Lorsque vous sélectionnez des algorithmes et des structures de données appropriés, vous minimisez le nombre de cycles de processeur et d'opérations de mémoire nécessaires pour accomplir une tâche. Moins de cycles de processeur et d'opérations de mémoire entraînent une consommation d'énergie plus faible.

Choisir des algorithmes pour une complexité temporelle optimale

Privilégiez les algorithmes qui obtiennent le résultat requis dans le délai le plus court. Cette approche permet de réduire la durée d'utilisation des ressources. Pour sélectionner des algorithmes qui optimisent l'utilisation des ressources, utilisez les approches suivantes :

  • Concentrez-vous sur la réduction de la complexité : pour évaluer la complexité, ne vous contentez pas des métriques d'exécution et tenez compte de la complexité théorique de l'algorithme. Par exemple, par rapport au tri à bulles, le tri par fusion réduit considérablement la charge de calcul et la consommation d'énergie pour les grands ensembles de données.
  • Évitez les tâches redondantes : utilisez les fonctions intégrées et optimisées dans le langage de programmation ou le framework de votre choix. Ces fonctions sont souvent implémentées dans un langage de niveau inférieur et plus économe en énergie, comme C ou C++. Elles sont donc mieux optimisées pour le matériel sous-jacent que les fonctions codées sur mesure.

Sélectionner des structures de données pour l'efficacité

Les structures de données que vous choisissez déterminent la vitesse à laquelle les données peuvent être récupérées, insérées ou traitées. Cette vitesse affecte l'utilisation du processeur et de la mémoire. Pour sélectionner des structures de données efficaces, utilisez les approches suivantes :

  • Optimisez la recherche et la récupération : pour les opérations courantes telles que la vérification de l'existence d'un élément ou la récupération d'une valeur spécifique, privilégiez les structures de données optimisées pour la vitesse. Par exemple, les tables de hachage ou les ensembles de hachage permettent des recherches en temps quasi constant, ce qui est une approche plus économe en énergie que la recherche linéaire dans un tableau.
  • Minimiser l'empreinte mémoire : des structures de données efficaces permettent de réduire l'empreinte mémoire globale d'une application. L'accès à la mémoire et sa gestion étant réduits, la consommation d'énergie est plus faible. De plus, un profil de mémoire plus léger permet aux processus de s'exécuter plus efficacement, ce qui vous permet de reporter les mises à niveau des ressources.
  • Utilisez des structures spécialisées : utilisez des structures de données spécialement conçues pour un problème donné. Par exemple, utilisez une structure de données trie pour une recherche rapide de préfixes de chaînes et une file d'attente à priorité lorsque vous n'avez besoin d'accéder qu'à la valeur la plus élevée ou la plus basse de manière efficace.

Optimiser les opérations de calcul et de données

Lorsque vous développez un logiciel, concentrez-vous sur une utilisation efficace et proportionnelle des ressources dans l'ensemble de la pile technologique. Considérez le processeur, la mémoire, le disque et le réseau comme des ressources limitées et partagées. Reconnaissez qu'une utilisation efficace des ressources entraîne des réductions tangibles des coûts et de la consommation d'énergie.

Optimiser l'utilisation du processeur et le temps d'inactivité

Pour minimiser le temps que le processeur passe dans un état actif et énergivore sans effectuer de travail utile, utilisez les approches suivantes :

  • Privilégiez la logique événementielle au polling : remplacez les boucles d'attente ou les vérifications constantes (polling) gourmandes en ressources par une logique événementielle. Une architecture basée sur les événements garantit que les composants d'une application ne fonctionnent que lorsqu'ils sont déclenchés par des événements pertinents. Cette approche permet un traitement à la demande, ce qui élimine la nécessité d'un polling gourmand en ressources.
  • Évitez une fréquence élevée constante : écrivez du code qui ne force pas le processeur à fonctionner constamment à sa fréquence maximale. Pour minimiser la consommation d'énergie, les systèmes inactifs doivent pouvoir passer en mode basse consommation ou en mode veille.
  • Utilisez le traitement asynchrone : pour éviter que les threads ne soient verrouillés pendant les temps d'attente inactifs, utilisez le traitement asynchrone. Cette approche libère des ressources et permet une meilleure utilisation globale des ressources.

Gérer efficacement la mémoire et les E/S disque

Une utilisation inefficace de la mémoire et du disque entraîne un traitement inutile et une consommation d'énergie accrue. Pour gérer efficacement la mémoire et les E/S, utilisez les techniques suivantes :

  • Gestion stricte de la mémoire : prenez des mesures pour libérer de manière proactive les ressources mémoire inutilisées. Évitez de conserver de grands objets en mémoire plus longtemps que nécessaire. Cette approche permet d'éviter les goulots d'étranglement des performances et de réduire la puissance consommée pour l'accès à la mémoire.
  • Optimisez les E/S de disque : réduisez la fréquence des interactions de lecture et d'écriture de votre application avec les ressources de stockage persistant. Par exemple, utilisez une mémoire tampon intermédiaire pour stocker les données. Écrivez les données dans un espace de stockage persistant à intervalles fixes ou lorsque le tampon atteint une certaine taille.
  • Opérations par lot : regroupez les opérations de disque fréquentes et de petite taille en opérations par lot moins nombreuses et plus volumineuses. Une opération par lot consomme moins d'énergie que de nombreuses petites transactions individuelles.
  • Utilisez la compression : réduisez la quantité de données écrites sur les disques ou lues à partir de ceux-ci en appliquant des techniques de compression de données appropriées. Par exemple, pour compresser les données que vous stockez dans Cloud Storage, vous pouvez utiliser le transcodage décompressif.

Minimiser le trafic réseau

Les ressources réseau consomment beaucoup d'énergie lors des opérations de transfert de données. Pour optimiser la communication réseau, utilisez les techniques suivantes :

  • Réduisez la taille de la charge utile : concevez vos API et vos applications de manière à ne transférer que les données nécessaires à une requête. Évitez de récupérer ou de renvoyer de grandes structures JSON ou XML lorsque seuls quelques champs sont requis. Assurez-vous que les structures de données renvoyées sont concises.
  • Réduisez les allers-retours : pour réduire le nombre d'allers-retours réseau nécessaires pour effectuer une action utilisateur, utilisez des protocoles plus intelligents. Par exemple, préférez HTTP/3 à HTTP/1.1, choisissez GraphQL plutôt que REST, utilisez des protocoles binaires et consolidez les appels d'API. Lorsque vous réduisez le volume d'appels réseau, vous réduisez la consommation d'énergie de vos serveurs et des appareils des utilisateurs finaux.

Implémenter l'optimisation du frontend

L'optimisation du frontend minimise les données que vos utilisateurs finaux doivent télécharger et traiter, ce qui permet de réduire la charge sur les ressources des appareils des utilisateurs finaux.

Minimiser le code et les composants

Lorsque les utilisateurs finaux doivent télécharger et traiter des ressources plus petites et mieux structurées, leurs appareils consomment moins d'énergie. Pour minimiser le volume de téléchargement et la charge de traitement sur les appareils des utilisateurs finaux, utilisez les techniques suivantes :

  • Minimisation et compression : pour les fichiers JavaScript, CSS et HTML, supprimez les caractères inutiles tels que les espaces blancs et les commentaires à l'aide des outils de minimisation appropriés. Assurez-vous que les fichiers tels que les images sont compressés et optimisés. Vous pouvez automatiser la réduction et la compression des composants Web à l'aide d'un pipeline CI/CD.
  • Chargement différé : chargez les images, les vidéos et les éléments non essentiels uniquement lorsqu'ils sont réellement nécessaires, par exemple lorsqu'ils défilent dans la fenêtre d'affichage d'une page Web. Cette approche réduit le volume de transfert de données initial et la charge de traitement sur les appareils des utilisateurs finaux.
  • Regroupez le code JavaScript dans des fichiers plus petits : éliminez le code inutilisé de vos groupes JavaScript en utilisant des outils de regroupement de modules modernes et des techniques comme le tree shaking. Cette approche permet d'obtenir des fichiers plus petits qui se chargent plus rapidement et utilisent moins de ressources serveur.
  • Mise en cache du navigateur : utilisez des en-têtes de mise en cache HTTP pour indiquer au navigateur de l'utilisateur de stocker les éléments statiques en local. La mise en cache du navigateur permet d'éviter les téléchargements répétés et le trafic réseau inutile lors des visites ultérieures.

Prioriser une expérience utilisateur légère

La conception de votre interface utilisateur peut avoir un impact significatif sur la complexité de calcul pour le rendu du contenu du frontend. Pour créer des interfaces frontend offrant une UX légère, utilisez les techniques suivantes :

  • Rendu efficace : évitez les manipulations fréquentes et gourmandes en ressources du Document Object Model (DOM). Écrivez du code qui minimise la complexité du rendu et élimine les rendus inutiles.
  • Modèles de conception légers : dans la mesure du possible, privilégiez les sites statiques ou les progressive web apps (PWA). Ces sites et applications se chargent plus rapidement et nécessitent moins de ressources serveur.
  • Accessibilité et performances : les sites responsifs et à chargement rapide sont souvent plus durables et accessibles. Une conception optimisée et épurée réduit les ressources consommées lors du rendu du contenu. Les sites Web optimisés pour les performances et la vitesse peuvent générer des revenus plus élevés. Selon une étude de Deloitte et Google intitulée Milliseconds Make Millions, une amélioration de 0,1 seconde (100 ms) de la vitesse d'un site entraîne une augmentation de 8,4 % des conversions pour les sites de vente au détail et de 9,2 % du panier moyen.
Précédent
Optimiser l'utilisation des ressources
Suivant
Optimiser les données et le stockage