Ajustement de performance et techniques d'optimisation

Applications sans serveur avec AWS Lambda

Claudio Canales

Senior DevOps Engineer

Performance = latence + coût

• Vous payez pour le temps.
• Accorder la performance, c'est aussi optimiser les coûts.
• Mesurer avant d'ajuster.
• Changer un élément à la fois.

Où passe le temps

• Initialisation.
• Exécution du gestionnaire.
• Attente des appels externes.

Démarrage à froid vs à chaud

Démarrage à froid

• Lambda a besoin d'un nouvel environnement.

Démarrage à chaud

• Réutilise un environnement existant.
• Le gestionnaire s'exécute avec moins de surcharge.

Travail d'init vs travail du gestionnaire

• Les importations et la configuration globale s'exécutent à l'initialisation.
• Une initialisation lourde ralentit les démarrages à froid.
• La durée d'initialisation apparaît dans les mesures.

Réutiliser les clients entre appels à chaud

• Créer un client à chaque appel répète le coût.
• Le réutiliser quand l'environnement est chaud.

Modèle de code : client à l'extérieur du gestionnaire

import boto3
sts = boto3.client("sts")
def handler(event, context):
    return sts.get_caller_identity()

Mettre en cache ce qui est possible

• Garder les données en mémoire.
• Utiliser /tmp pour de petits fichiers temporaires.
• Mettre en cache prudemment et invalider au besoin.

Alléger les dépendances

• Les gros modules se chargent plus lentement.
• Retrancher ce que vous n'utilisez pas.
• Garder les dépendances au minimum.

Consigner judicieusement

• Trop de journalisation ajoute des coûts et du bruit.
• Viser de petits messages structurés.
• Rester repérable ; faciliter la traçabilité et le débogage.

Réduire la surcharge des appels externes

• Les appels à d'autres services sont la partie la plus lente.
• Réduire les appels ; regrouper au besoin.
• Définir des temporisations pour éviter les blocages en cas d'échec.

La mémoire influe aussi sur le CPU

• Le CPU évolue avec la mémoire.
• Le code lié au CPU peut finir plus vite.
• Plus de mémoire peut réduire la durée ou le coût.
• Tester pour trouver la valeur optimale.

Trouver le point optimal de coût

• Le meilleur réglage mémoire minimise le coût total.
• La courbe baisse, puis s'aplatit ou remonte.
• Refaire des tests après chaque changement.

Mesurer avec CloudWatch

• Suivre la durée et la durée d'init.
• Suivre les erreurs et limitations.
• Surveiller les latences en queue (p95, p99).

Réduire les démarrages à froid

• Réduire ce qui s'exécute à l'initialisation.
• Garder un paquet léger.
• Réutiliser les configurations coûteuses.
• Envisager des environnements provisionnés.

Points clés à retenir

• Savoir où passe le temps.
• Réutiliser les clients et mettre en cache prudemment.
• La mémoire change le CPU et la durée.
• Mesurer chaque changement.

Passons à la pratique !

Applications sans serveur avec AWS Lambda