Qu'est-ce qu'un démarrage à froid ?

Dans le contexte de l'informatique sans serveur, un « démarrage à froid » fait référence à la latence de première exécution ou au temps qu'il faut à une fonction pour commencer le traitement après qu'elle n'a pas été appelée depuis longtemps. Par exemple, lorsqu'un ordinateur est allumé après avoir été éteint, il peut avoir besoin d'un certain temps pour atteindre ses pleines performances.

Les démarrages à froid sont fondamentaux pour quiconque débute avec des architectures sans serveur. Ils influencent les performances et la convivialité de votre application, en particulier en ce qui concerne les interactions où les durées de délai d'attente doivent être respectées dans les plus brefs délais.

Les démarrages à froid se produisent dans les circonstances suivantes.

• Premier appel : Il existe deux cas : le premier est lorsqu'une fonction est appelée pour la première fois après le déploiement des applications ou après la mise à jour du code.
• la mise à l'échelle à partir de zéro : Lorsqu'une fonction passe de zéro occurrence à la réception d'appels après une période d'inactivité.
• Réallocation des ressources : Lorsque le fournisseur de cloud réalloue des ressources ou si la base de la fonction change vers d'autres hôtes, cela peut conduire à des instances de fonction froides.
• Délai d'expiration : Si une instance de fonction atteint son temps d'exécution maximal ou a dépassé son temps d'inactivité, elle peut être terminée, ce qui signifie que si elle est invoquée à nouveau, elle redémarrera à zéro.

Un défi majeur associé aux démarrages à froid est la latence supplémentaire. Cette latence peut être observée sous la forme :

• Réponses différées : Bien que votre application fournisse généralement des réponses rapides, les utilisateurs peuvent parfois rencontrer des retards qui pourraient affecter leur expérience.
• Débit réduit : Les démarrages à froid peuvent nécessiter une augmentation progressive de la capacité de votre application à gérer les demandes simultanées, en particulier pendant les périodes de forte utilisation.
• Variations de performance : Le degré auquel les durées de démarrage à froid changent au fil du temps peut influencer l'efficacité de l'application, offrant des possibilités à la fois pour rationaliser les temps de réponse et consolider la constance.

La durée d'un démarrage à froid Lambda peut varier en fonction de différents facteurs, tels que :

• Taille et dépendances de la fonction : Plus la fonction est volumineuse, plus les dépendances sont nombreuses et plus le démarrage à froid typique prend du temps.
• Environnement d'exécution : L'environnement d'exécution initial sélectionné (par exemple, Node.js, Python, Java, etc.) détermine nécessairement un facteur tel que le temps de démarrage à froid en raison des différences dans les processus d'initialisation et de chargement.
• Optimisations du fournisseur de cloud : Au fil du temps, les fournisseurs de cloud fournissent constamment des optimisations pour réduire autant que possible le temps de démarrage à froid ; cependant, il n'est pas fixe ou prévisible.

Dans l'ensemble, les démarrages à froid de Lambda peuvent varier entre une demi-seconde et quelques secondes. Ainsi, pour obtenir des données précises et observer comment les durées de démarrage à froid reflètent les besoins de vos fonctions et de votre environnement afin d'obtenir des informations précises.

Voici quelques façons de réduire ou au moins de gérer les démarrages à froid de Lambda :

• Optimisation des fonctions :
  • Supprimez le code et les dépendances inutilisés pour réduire la taille de la fonction.
  • Les méthodes de tree-shaking ou de fractionnement de code doivent être utilisées pour réduire la quantité de code chargé pendant l'initialisation.
  • Améliorez la distribution des packages et les workflows de résolution des dépendances des packages.

• Provisionnement simultané :

Configurez le provisionnement simultané pour maintenir le nombre spécifique d'instances de fonction actives afin que les demandes entrantes ne provoquent pas un démarrage à froid pour ces instances.

• Requêtes d'échauffement :

Parfois, vous devez envoyer des requêtes factices à vos fonctions afin qu'elles soient échauffées lorsque les demandes réelles des utilisateurs arrivent.

• Traitement asynchrone :

Pour les opérations non critiques, il peut être préférable de refactoriser les demandes des utilisateurs à partir des fonctions en introduisant d'autres modèles asynchrones afin que les démarrages à froid aient un effet minimal.

• Mise en cache :

Introduisez des mécanismes de mise en cache appropriés qui stockent les données fréquemment consultées ou les résultats précalculés afin de réduire le nombre d'appels de fonction et ainsi diminuer les occurrences de démarrages à froid.