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

En informatique serverless, un « démarrage à froid » (cold start) est le temps nécessaire à une fonction pour commencer à s'exécuter après une longue période d'inactivité. Avec l'inférence d'IA, le chargement d'un modèle peut prendre plusieurs minutes, voire beaucoup plus, comme pour cette charge de travail de NetEase Games qui a pris pas moins de 42 minutes. Lorsqu'un ordinateur est allumé après avoir été éteint, il peut avoir besoin de temps pour atteindre ses pleines performances.

Les démarrages à froid sont bien connus de tous ceux qui débutent avec les architectures serverless. Ils affectent les performances et l'utilisabilité de votre application, en particulier lors d'interactions où les délais d'expiration doivent être les plus courts possibles.

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

• Premier appel : Cela se produit 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 que la base de la fonction change d'hôte, cela peut entraîner 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émarrage à chaud a l'effet inverse : la requête atteint une instance qui est toujours en cours d'exécution, de sorte que l'étape de configuration est évitée.

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 requêtes simultanées, en particulier pendant les périodes de forte utilisation.
• Variations de performance : Les chiffres de démarrage à froid varient d'une invocation à l'autre, de sorte que serverless les temps de réponse ne peuvent pas être prédits sans surveillance serverless.

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 moins de 100 ms et plus d'une seconde. Vérifiez vos propres fonctions pour 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.

Minimisez le temps de démarrage à froid de Lambda en procédant comme suit :

• 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.
• Restauration d'instantané : Lambda SnapStart, pour les environnements d'exécution tels que Java, fournit un instantané sauvegardé d'une fonction initialisée au lieu de la redémarrer afin de réduire la latence.
• 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. Le préchargement de la fonction au démarrage fonctionne de la même manière : NetEase Games a réduit le temps de chargement d'un modèle d'IA de 42 à 14 minutes grâce à un cache, puis à 3 minutes avec le préchargement (CNCF, 2026).