Le serverless et l'informatique en périphérie (edge)
Partie 2 sur 4
3Comment s’exécute une fonction
3.1Le cycle de vie
Quand un événement arrive, le fournisseur cherche une instance déjà prête de la fonction. S’il n’en trouve pas, il en crée une : il prépare un petit environnement isolé (souvent une micro-machine virtuelle ou un conteneur très léger), y charge le code, puis lance l’exécution. Une fois terminée, l’instance reste souvent disponible quelques minutes, au cas où un autre événement arriverait, puis elle est détruite. Si cent événements arrivent en même temps, cent instances sont créées. C’est ce qui donne au serverless sa mise à l’échelle automatique : de zéro à plusieurs milliers d’exécutions, sans que personne ne configure rien.
3.2Le démarrage à froid
La création d’une nouvelle instance prend du temps. On l’appelle le démarrage à froid (cold start) : à la première exécution après une période d’inactivité, il faut préparer la machine, charger le code et initialiser le programme, ce qui peut ajouter de quelques dizaines de millisecondes à plusieurs secondes selon le langage et la taille du code. Les exécutions suivantes, sur une instance déjà « chaude », sont beaucoup plus rapides (figure 2).
Ce défaut est parfaitement acceptable pour une tâche de fond (le redimensionnement d’une photo), beaucoup moins pour un service où l’utilisateur attend une réponse immédiate. Les parades sont connues : réduire la taille du code et de ses dépendances, choisir un langage au démarrage rapide, demander au fournisseur de garder un certain nombre d’instances « au chaud » (au prix d’une facturation réduite en permanence), ou utiliser des environnements d’exécution plus légers que les conteneurs, comme les isolats (partie 6.3).
3.3Les contraintes de ce modèle
Programmer pour le serverless impose des règles que le développeur doit accepter.
- Durée limitée. Une exécution est plafonnée (de quelques secondes à quinze minutes selon les produits). Un traitement long doit être découpé ou confié à un autre service.
- Pas de mémoire entre deux exécutions. Une fonction est dite sans état : elle ne peut pas compter sur ce qu’elle a stocké en mémoire lors d’un appel précédent, puisque l’instance peut avoir disparu. Tout ce qui doit durer va dans une base ou dans un stockage.
- Ressources bornées. Mémoire, processeur et espace disque temporaire sont limités, et fixés à l’avance.
- Exécutions multiples. Un même événement peut parfois déclencher deux exécutions (cas de relance après erreur) : la fonction doit donc être idempotente, c’est-à-dire donner le même résultat final si on la répète (par exemple, ne pas débiter deux fois un client).
- Tests et débogage plus délicats. L’environnement du fournisseur est difficile à reproduire sur son poste ; on utilise des outils d’émulation et de bonnes pratiques d’observation (voir l’observabilité).
3.4Écrire et déployer
Un développeur écrit sa fonction, la décrit (nom, déclencheur, mémoire, droits) dans un fichier de configuration, puis la déploie avec un outil en ligne de commande. La description de l’infrastructure sous forme de fichiers (voir l’infrastructure sous forme de code) est particulièrement adaptée : toute l’application, fonctions, droits et services gérés, peut être recréée à l’identique par un simple déploiement. Des cadres de travail (en anglais frameworks) facilitent la tâche et unifient la configuration entre fournisseurs.
Pour s’exercer
Exercice 2 : estimer une facture
Une fonction de 1 Go de mémoire s’exécute en 500 ms et est appelée 2 millions de fois par mois. Combien de Go-secondes cela représente-t-il ?
Voir la réponse
2 000 000 × 0,5 s × 1 Go = 1 000 000 Go-secondes. On multiplie ensuite par le tarif du fournisseur, qui varie, et on ajoute les coûts annexes (appels de passerelle, transfert de données, journaux). Réduire la mémoire à 512 Mo ou la durée à 250 ms diviserait la consommation par deux.
Exercice 3 : le démarrage à froid
Une application de réservation répond en 80 ms la plupart du temps, mais parfois en 2 secondes. Quelle cause probable, et quelles parades ?
Voir la réponse
Probablement le démarrage à froid : après une période sans appel, la fonction doit être relancée. Parades : alléger le code et ses bibliothèques, choisir un langage au démarrage rapide, demander des instances gardées au chaud, ou déplacer la partie sensible vers un conteneur toujours allumé ou un environnement de périphérie à isolats.
Exercice 4 : concevoir une fonction sans état
Une fonction compte les visiteurs en incrémentant une variable en mémoire. Pourquoi le compte est-il faux, et comment corriger ?
Voir la réponse
Chaque exécution peut tourner sur une instance différente, détruite entre deux appels, avec sa propre variable : le total n’est donc jamais cumulé. Il faut stocker le compteur dans un service externe (base de données ou cache) et utiliser une opération d’incrémentation atomique pour que deux exécutions simultanées ne s’écrasent pas.
Exercice 5 : la boucle infernale
Une fonction se déclenche à chaque fichier déposé dans un dossier, redimensionne l’image et l’enregistre dans le même dossier. Que se passe-t-il, et comment l’éviter ?
Voir la réponse
Chaque image redimensionnée est un nouveau dépôt, qui redéclenche la fonction, ce qui crée des fichiers à l’infini et une facture qui grimpe. Solution : écrire le résultat dans un autre dossier que celui qui sert de déclencheur, ou filtrer les événements (ne déclencher que sur les fichiers d’origine), et mettre un plafond de dépense avec une alerte.
4Pour quoi faire, et pour quoi ne pas faire
4.1Les cas où il brille
- Les charges irrégulières. Un site d’événement, une billetterie, une application de campagne, qui reçoivent des pics brutaux puis presque rien : le serverless s’adapte et ne coûte rien entre deux pics.
- Les tâches en arrière-plan. Redimensionnement d’images, conversion de fichiers, envoi de courriels, traitement de messages, nettoyages programmés.
- Les interfaces d’API légères. Une API qui reçoit quelques requêtes à la seconde, ou des « webhooks » (notifications automatiques envoyées par un service à une adresse).
- Les prototypes et les petites équipes. Quand on n’a ni le temps ni la compétence pour gérer des serveurs, on lance rapidement une idée.
- Le collage entre services. Quelques lignes de code qui relient un service à un autre, par exemple copier une donnée d’un système vers un autre.
4.2Les cas à éviter
- Les charges constantes et élevées. Si une fonction tourne en permanence à pleine charge, un serveur loué au mois sera nettement moins cher qu’une facturation à la milliseconde.
- Les calculs très longs ou très lourds. Entraîner un modèle, traiter de gros volumes d’un seul tenant : les plafonds de durée et de mémoire l’interdisent.
- Les besoins de latence très faible et régulière. Le démarrage à froid introduit une variabilité qui gêne les systèmes temps réel.
- Les connexions longues. Une discussion en direct, un flux vidéo, qui maintiennent un lien ouvert pendant des heures, s’accordent mal à des fonctions éphémères (même si des services spécialisés existent).
- Les logiciels existants. Réécrire une grosse application en fonctions coûte souvent plus cher que ce que le serverless rapporte.
4.3Serverless et microservices
Le serverless est parfois présenté comme l’étape suivante des microservices (voir les microservices) : au lieu de découper une application en quelques dizaines de services, on la découpe en centaines de fonctions. Les deux approches partagent les mêmes difficultés (communication entre éléments, suivi des erreurs, gestion de la cohérence des données) et les mêmes avantages (déploiement indépendant, mise à l’échelle fine). Une équipe peut parfaitement mélanger les deux : un service principal dans un conteneur, et des fonctions pour les tâches annexes.