Développer des logiciels économes en énergie

Last reviewed 2026-01-28 UTC

Ce principe du pilier "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 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 que consomment les appareils des utilisateurs finaux lorsqu'ils accèdent à vos applications.

Pour créer des logiciels écoénergétiques, 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 afin de créer des logiciels qui minimisent l'impact environnemental des charges de travail cloud, consultez l' Google Cloud e-book Créer des logiciels de manière durable.

Recommandations

Les recommandations de cette section sont regroupées dans les domaines d'intérêt suivants :

Minimiser le travail de calcul

Pour écrire des logiciels écoénergétiques, vous devez minimiser la quantité totale de travail de calcul effectué 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 un code simple et ciblé

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

  • Éliminer la logique redondante et les fonctionnalités superflues : é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, le cas échéant.
  • Éviter 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 de la sortie.
  • Prioriser la lisibilité et la réutilisabilité du code : écrivez du code lisible et réutilisable. Cette approche minimise la duplication et suit le principe "Don't repeat yourself" (DRY), qui peut contribuer à 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 le même travail à plusieurs reprises. Un taux de réussite du cache élevé entraîne une réduction presque linéaire de la consommation d'énergie par requête. Pour mettre en œuvre 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 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 d'API : pour éviter les appels réseau redondants et coûteux, mettez en cache les résultats des requêtes d'API fréquentes.
  • Prioriser la mise en cache en mémoire : pour éliminer les opérations d'E/S disque lentes et les requêtes de base de données complexes, stockez les données dans une mémoire haute vitesse (RAM).
  • Sélectionner des stratégies d'écriture de cache appropriées :
    • La stratégie d'écriture directe 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 réussite du 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.
  • Utiliser des stratégies d'expulsion intelligentes : maintenez le cache simple 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 stratégies telles que la valeur TTL (Time To Live), le moins récemment utilisé (LRU) et le moins fréquemment utilisé (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 effectuer 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 atteignent 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 :

  • Se concentrer 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, tri par fusion réduit considérablement la charge de calcul et la consommation d'énergie pour les ensembles de données volumineux.
  • Éviter le travail redondant : 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 écoénergétique comme C ou C++, ce qui les rend 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 :

  • 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, préférez 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 écoénergétique que la recherche linéaire dans un tableau.
  • Minimiser l'espace mémoire utilisé : des structures de données efficaces contribuent à réduire l'espace mémoire utilisé global d'une application. La réduction de l'accès à la mémoire et de la gestion de la mémoire entraîne une consommation d'énergie plus faible. De plus, un profil de mémoire plus simple 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 qui sont spécialement conçues pour un problème donné. Par exemple, utilisez une structure de données trie pour la recherche rapide de préfixes de chaînes 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 basse.

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 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 significatif, utilisez les approches suivantes :

  • Préférer la logique basée sur les événements au sondage : remplacez les boucles occupées ou les vérifications constantes (sondages) 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 de sondages gourmands en ressources.
  • Éviter une fréquence élevée constante : écrivez du code qui n'oblige 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.
  • Utiliser 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 entraîne une utilisation globale plus élevée 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 de mémoire inutilisées. Évitez de conserver des objets volumineux en mémoire pendant des périodes plus longues 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 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 un tampon de mémoire intermédiaire pour stocker les données. Écrivez les données dans un stockage persistant à intervalles fixes ou lorsque le tampon atteint une certaine taille.
  • Opérations par lot : regroupez les petites opérations disque fréquentes en un nombre plus restreint d'opérations par lot plus importantes. 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.

Minimiser le trafic réseau

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

  • Minimiser la taille de la charge utile : concevez vos API et applications pour 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é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, 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.

Mettre en œuvre l'optimisation du frontend

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

Minimiser le code et les assets

Lorsque les utilisateurs finaux doivent télécharger et traiter des ressources plus petites et plus efficacement 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 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 assets Web à l'aide d'un pipeline CI/CD.
  • Chargement différé : ne chargez les images, les vidéos et les assets non critiques que 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 de transfert de données initial et la charge de traitement sur les appareils des utilisateurs finaux.
  • Groupes JavaScript plus petits : éliminez le code inutilisé de vos groupes JavaScript à l’aide de regroupeurs de modules modernes et de techniques telles que le « tree shaking ». Cette approche génère des fichiers plus petits qui se chargent plus rapidement et utilisent moins de ressources serveur.
  • Mise en cache dans le navigateur : utilisez des en-têtes de mise en cache HTTP pour demander au navigateur de l'utilisateur de stocker les assets statiques localement. La mise en cache dans le 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 du rendu du contenu frontend. Pour créer des interfaces frontend qui offrent une expérience utilisateur légère, utilisez les techniques suivantes :

  • Rendu efficace : évitez la manipulation fréquente et gourmande en ressources du DOM (Document Object Model). Écrivez du code qui minimise la complexité du rendu et élimine les rendus inutiles.
  • Modèles de conception légers : le cas échéant, préférez 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, 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 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