Développer des logiciels économes en énergie

Last reviewed 2026-10-28 UTC

Ce principe du pilier "Développement durable" 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 du principe

Lorsque vous suivez 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 Build Software Sustainably.

Recommandations

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

Réduire le raisonnement informatique

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

Écrire du code concis et ciblé

Pour écrire le code minimal essentiel pour obtenir les résultats requis, utilisez les approches suivantes :

  • Éliminez la logique redondante et l'excès de fonctionnalités : écrivez du code qui n'exécute que les fonctions essentielles. Évitez les fonctionnalités qui augmentent la surcharge de calcul et la complexité, mais n'apportent pas de valeur mesurable à vos utilisateurs.
  • Refactorisation : 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, le cas échéant.
  • Évitez les opérations inutiles : ne calculez pas de valeur et n'exécutez pas d'action tant que le résultat n'est pas nécessaire. Utilisez des techniques telles que l'évaluation paresseuse, qui retardent les calculs jusqu'à ce qu'un composant dépendant de l'application ait besoin du résultat.
  • Donnez la priorité à 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 garantit qu'une application n'effectue pas la même tâche de manière répétée. 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 hautes performances. Par exemple, utilisez un service de mise en cache en mémoire tel que 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 sur le 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 API fréquentes.
  • Priorisez la mise en cache en mémoire : pour éliminer les opérations d'E/S lentes sur le disque et les requêtes de base de données complexes, stockez les données dans une mémoire à grande vitesse (RAM).
  • Sélectionnez les stratégies d'écriture dans le cache appropriées :
    • La stratégie d'écriture simultanée garantit que les données sont écrites de manière synchrone dans le cache et dans le stockage persistant. Cette stratégie augmente la probabilité de succès de cache, de sorte que le stockage persistant reçoit moins de requêtes de lecture énergivores.
    • La stratégie de réécriture (écriture différée) 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. 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 : gardez 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), la règle LRU (Least Recently Used) et la règle LFU (Least Frequently Used).

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 effectuer une tâche. La réduction du nombre de cycles de processeur et d'opérations de mémoire entraîne une diminution de la consommation d'énergie.

Choisir des algorithmes pour une complexité temporelle optimale

Donnez la priorité aux algorithmes qui obtiennent le résultat requis en un minimum de temps. 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 des 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 personnalisées.

Sélectionner des structures de données pour plus d'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 :

  • Optimiser 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.
  • Réduire l'espace mémoire utilisé : des structures de données efficaces permettent de réduire l'espace mémoire global utilisé par une application. La réduction de l'accès à la mémoire et de la gestion de la mémoire entraîne une diminution de la consommation d'énergie. 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.
  • Utiliser 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 rechercher rapidement des préfixes de chaîne, et une file d'attente prioritaire lorsque vous n'avez besoin d'accéder efficacement qu'à la valeur la plus élevée ou la plus faible.

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

Lorsque vous développez des logiciels, concentrez-vous sur une utilisation efficace et proportionnelle des ressources sur l'ensemble de la pile technologique. Traitez le processeur, la mémoire, le disque et le réseau comme des ressources limitées et partagées. Reconnaître 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 réduire le temps que le processeur passe dans un état actif et énergivore sans effectuer de travail significatif, utilisez les approches suivantes :

  • Privilégiez la logique basée sur les événements plutôt que l'interrogation : remplacez les boucles d'attente active ou les vérifications constantes (interrogation) gourmandes en ressources par une logique basée sur les événements. 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 le besoin d'interrogations gourmandes en ressources.
  • Évitez une fréquence élevée constante : écrivez du code qui ne force pas le processeur à fonctionner en permanence à 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 de disque

Une utilisation inefficace de la mémoire et du disque entraîne un traitement inutile et une augmentation de la consommation d'énergie. 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 de mémoire inutilisées. Évitez de conserver des objets volumineux en mémoire plus longtemps que nécessaire. Cette approche évite les goulots d'étranglement des performances et réduit la consommation d'énergie pour l'accès à la mémoire.
  • Optimiser 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 petites opérations fréquentes sur le disque en un nombre réduit d'opérations par lot plus volumineuses. Une opération par lot consomme moins d'énergie que de nombreuses petites transactions individuelles.
  • Utiliser 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.

Réduire 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éduire 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 des structures JSON ou XML volumineuses lorsque seuls quelques champs sont requis. Assurez-vous que les structures de données renvoyées sont concises.
  • Réduire 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, privilégiez HTTP/3 par rapport à HTTP/1.1, choisissez GraphQL plutôt que REST, utilisez des protocoles binaires et consolidez les appels d'API. En réduisant 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 de l'interface

L'optimisation de l'interface 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.

Réduire le code et les éléments

Lorsque les utilisateurs finaux doivent télécharger et traiter des ressources plus petites et structurées plus efficacement, leurs appareils consomment moins d'énergie. Pour réduire 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 d'outils de minimisation appropriés. Assurez-vous que les fichiers tels que les images sont compressés et optimisés. Vous pouvez automatiser la minimisation et la compression des éléments Web à l'aide d'un pipeline CI/CD.
  • Chargement différé : chargez les images, les vidéos et les éléments non critiques uniquement lorsqu'ils sont réellement nécessaires, par exemple lorsque ces éléments défilent dans la fenêtre d'affichage d'une page Web. Cette approche réduit le volume du transfert de données initial et la charge de traitement sur les appareils des utilisateurs finaux.
  • Bundles JavaScript plus petits : éliminez le code inutilisé de vos bundles JavaScript à l'aide de bundlers de modules modernes et de techniques telles que 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 localement. 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 l'expérience utilisateur (UX) légère

La conception de votre interface utilisateur peut avoir un impact significatif sur la complexité de calcul pour l'affichage du contenu de l'interface. Pour créer des interfaces d'interface qui fournissent une expérience utilisateur légère, utilisez les techniques suivantes :

  • Rendu efficace : évitez de manipuler fréquemment le Document Object Model (DOM), car cela consomme beaucoup de ressources. Écrivez du code qui minimise la complexité du rendu et élimine les rendus inutiles.
  • Modèles de conception légers : le cas échéant, 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 de l'affichage du contenu. Les sites Web optimisés pour les performances et la vitesse peuvent vous aider à générer plus de revenus. Selon une étude de Deloitte et Google, Milliseconds Make Millions, une amélioration de 0,1 seconde (100 ms) de la vitesse du site entraîne une augmentation de 8,4 % des conversions pour les sites de vente au détail et une augmentation de 9,2 % de la valeur moyenne des commandes.
Précédent
Optimiser l'utilisation des ressources
Suivant
Optimiser les données et le stockage