Provuse: Platform-Side Function Fusion for Performance and Efficiency in FaaS Environments

Le papier présente Provuse, une optimisation transparente côté plateforme pour les environnements FaaS qui fusionne automatiquement les fonctions indépendamment déployées à l'exécution afin de réduire la latence et la consommation de ressources sans modifier le code des utilisateurs.

L'essentiel

🚀 Provuse : Le "Covoiturage" Magique pour les Applications Cloud

Imaginez que vous gérez un grand restaurant (votre application) où chaque plat est préparé par un chef différent (une "fonction").

1. Le Problème : La Cuisine en Mode "Chaos"

Dans le monde du FaaS (Function-as-a-Service, ou "Service de Fonction"), c'est un peu comme si chaque fois qu'un client commandait un plat, le restaurant :

1. Engageait un nouveau chef pour le faire cuire.
2. Le chef cuisinait le plat.
3. Le chef partait immédiatement.
4. Si ce plat nécessitait une sauce préparée par un autre chef, le premier chef devait appeler ce deuxième chef, qui devait aussi être engagé, cuisiner, puis partir.

Le résultat ?

• C'est lent : Chaque fois qu'on change de chef, il faut du temps pour qu'il arrive, mette son tablier et se mette au travail (ce qu'on appelle le "démarrage à froid").
• C'est cher : Vous payez le salaire du premier chef, puis celui du deuxième, même s'ils ne travaillent que quelques secondes. C'est ce qu'on appelle la "double facturation".

2. La Solution : Provuse, le Super-Manager

Les auteurs de l'article ont créé Provuse. Imaginez Provuse comme un super-manager invisible qui travaille pour le restaurant, mais qui ne demande rien aux chefs.

Son rôle est simple : Il observe les commandes.

• Si le Chef A appelle souvent le Chef B pour faire une sauce, Provuse se dit : "Attendez, ils travaillent toujours ensemble. Pourquoi les séparer ?"
• Au lieu d'avoir deux chefs dans deux cuisines séparées, Provuse fusionne leurs recettes dans une seule cuisine.
• Désormais, le Chef A et le Chef B travaillent côte à côte dans le même espace. Quand le plat A est prêt, il passe simplement le bol au Chef B sans avoir à appeler un autre restaurant.

3. Comment ça marche ? (L'Analogie du Camion de Déménagement)

Dans la vraie vie informatique, voici ce que fait Provuse :

1. Il regarde : Il détecte quand une fonction (un code) envoie une demande à une autre fonction de manière immédiate (comme si vous attendiez la réponse avant de continuer).
2. Il fusionne : Il prend les "boîtes" (les fichiers et le code) des deux fonctions et les met dans un seul grand conteneur.
3. Il remplace : Il envoie un nouveau conteneur géant qui contient les deux fonctions, et il supprime les deux petits anciens conteneurs.

Le plus important ? Les clients (les utilisateurs) ne voient rien. Ils commandent toujours le même plat, mais la cuisine est devenue beaucoup plus efficace.

4. Les Résultats : Plus Vite, Moins Cher

Les chercheurs ont testé cette idée sur deux types de "restaurants" (des plateformes informatiques) :

• Un petit restaurant rapide (tinyFaaS).
• Un grand réseau de restaurants géant (Kubernetes).

Les résultats sont impressionnants :

• ⏱️ Vitesse : Les plats arrivent 26 % plus vite. C'est comme si le temps d'attente à la caisse avait presque diminué d'un quart.
• 💰 Économie de ressources : Ils ont utilisé 53 % moins de mémoire RAM (l'espace de travail). C'est comme si le restaurant avait besoin de la moitié de l'électricité pour fonctionner.
• 🤝 Zéro effort : Les développeurs n'ont pas eu à changer une seule ligne de code. Provuse fait tout le travail sale à leur place.

En Résumé

Provuse, c'est comme si vous alliez au cinéma et que, au lieu de payer deux billets séparés pour voir deux films qui se suivent, le cinéma vous disait : "Hé, comme vous regardez les deux, on va les projeter ensemble dans la même salle pour que ce soit plus fluide et moins cher."

C'est une optimisation intelligente qui rend le "Cloud" (le nuage informatique) plus rapide et moins coûteux, sans que vous ayez à faire le moindre effort.

Résumé technique

Voici un résumé technique détaillé du papier de recherche « Provuse: Platform-Side Function Fusion for Performance and Efficiency in FaaS Environments » en français.

1. Problématique

Les plateformes FaaS (Function-as-a-Service) offrent une évolutivité et une rentabilité grâce à un modèle de paiement à l'usage. Cependant, elles souffrent de deux problèmes majeurs dans les applications complexes composées de multiples fonctions :

• Surcharge de latence et de ressources : L'appel entre fonctions (inter-function communication) introduit une latence réseau et des coûts d'initialisation répétés.
• Double facturation (Double Billing) : Dans les modèles de facturation fine (basés sur le temps d'exécution et les ressources allouées), lorsqu'une fonction appelle une autre de manière synchrone, les deux instances sont facturées simultanément, même si l'une attend simplement le résultat de l'autre. Cela crée des coûts redondants et une inefficacité des ressources.

Les optimisations existantes nécessitent souvent des modifications du code source par les développeurs (comme la fusion manuelle de fonctions), ce qui va à l'encontre de la simplicité du modèle FaaS.

2. Méthodologie : Provuse

Le papier propose Provuse, une solution d'optimisation transparente et côté plateforme (sans intervention du développeur). L'approche repose sur la fusion de fonctions (Function Fusion) effectuée dynamiquement à l'exécution.

Architecture et Composants

Le système introduit deux composants clés qui interagissent avec l'environnement FaaS existant :

1. Function Handler (Gestionnaire de fonctions) :
   • Déployé avec le code de la fonction, il orchestre les requêtes entrantes.
   • Il surveille les connexions sortantes (sockets) de chaque instance de fonction.
   • Il détecte les communications synchrone (où le thread d'appelant bloque en attendant la réponse) et identifie les paires de fonctions à fusionner.
   • Il notifie le composant Merger avec les identifiants des fonctions concernées.
2. Merger (Fusionneur) :
   • Reçoit la demande de fusion et interagit avec le runtime des conteneurs (ex: Docker, Kubernetes).
   • Il extrait les systèmes de fichiers des conteneurs des deux fonctions actives.
   • Il fusionne ces systèmes de fichiers en une image de conteneur unique, en préservant les identifiants originaux pour éviter les conflits de noms.
   • Il construit une nouvelle image de conteneur hébergeant les deux fonctions et un nouveau Function Handler.
   • Une fois le nouveau conteneur sain, le trafic est redirigé vers lui et les conteneurs originaux sont arrêtés.

Principes de Conception

• Transparence : Aucune modification du code de l'application n'est requise.
• Modèle "Bring-Your-Own-Function-Code" : La plateforme contrôle les points d'entrée et les artefacts de déploiement, permettant d'accéder directement aux sockets et aux fichiers pour effectuer la fusion.
• Indépendance du langage : Bien que le prototype utilise Python, les mécanismes de la plateforme sont agnostiques au langage.

3. Contributions Clés

• Optimisation côté plateforme : Déplacement de la responsabilité de la fusion des fonctions du développeur vers le fournisseur de cloud, rendant l'optimisation totalement transparente.
• Élimination du double facturation : En fusionnant les fonctions synchrones en une seule unité d'exécution, le temps d'attente et les ressources redondantes sont supprimés.
• Implémentations doubles : Le système a été implémenté et testé sur deux environnements distincts :
  • tinyFaaS : Une plateforme légère et orientée "edge".
  • Kubernetes : Une plateforme d'orchestration de conteneurs standard (utilisée par des solutions comme Knative).
• Preuve de concept robuste : Démonstration que la fusion automatique est compatible avec les frameworks d'orchestration de conteneurs modernes.

4. Résultats de l'Évaluation

Les auteurs ont évalué Provuse sur deux applications de référence (TREE et IOT) déployées sur tinyFaaS et Kubernetes, en comparant un déploiement "Vanilla" (standard) avec un déploiement optimisé par fusion.

• Réduction de la latence :
  • Réduction moyenne de la latence de bout en bout de 26,33 %.
  • Exemple spécifique (IOT sur tinyFaaS) : La latence médiane est passée de 807 ms à 574 ms (réduction de 28,9 %).
  • Exemple spécifique (TREE sur Kubernetes) : Réduction de 21,5 %.
• Réduction de l'utilisation des ressources (RAM) :
  • Réduction moyenne de la consommation de RAM de 53,57 %.
  • Cela s'explique par la réduction du nombre d'instances de fonctions concurrentes nécessaires pour traiter la même charge de travail.
• Stabilité : Les gains sont constants à travers les différents environnements (léger vs orchestration lourde) et types d'applications.

5. Signification et Perspectives

• Impact Économique et Technique : Provuse démontre que l'infrastructure serverless peut être optimisée de manière proactive pour réduire les coûts et améliorer les performances sans alourdir la charge cognitive des développeurs.
• Limitations actuelles :
  • La fusion réduit l'isolation entre les fonctions (elles partagent le même environnement d'exécution), ce qui impose de ne fusionner que des fonctions appartenant au même domaine de confiance.
  • Le prototype actuel ne supporte que le modèle "Bring-Your-Own-Function-Code" (analyse au niveau de l'appel) et non les conteneurs tiers ("Bring-Your-Own-Container").
  • Les bénéfices sont limités pour les applications déjà entièrement asynchrones ou non bloquantes.
• Avenir : Les auteurs suggèrent d'étendre cette approche à d'autres techniques d'optimisation (comme le peak shaving ou le pré-chauffage d'instances) et d'intégrer des modèles hybrides pour supporter des environnements de conteneurs plus complexes.

Conclusion : Provuse valide l'hypothèse que la fusion automatique de fonctions côté plateforme est une stratégie efficace pour résoudre les problèmes de latence et de facturation redondante dans les applications FaaS composées, ouvrant la voie à des systèmes serverless plus performants et économiques.