Fonctions Serverless en TypeScript : travail avancé avec AWS Lambda

Fonctions Serverless en TypeScript : niveau avancé dans AWS Lambda

L'architecture serverless est devenue la norme de facto pour la création d'applications évolutives et économiques. AWS Lambda est l'un des services les plus populaires pour implémenter des fonctions sans serveur. Si la syntaxe de base et les déclencheurs (API Gateway, S3, DynamoDB) sont déjà maîtrisés, il est temps de passer aux techniques avancées. Dans cet article, nous examinerons les aspects clés du développement professionnel de fonctions Lambda en TypeScript : de l'optimisation du démarrage à froid à l'intégration avec VPC et l'utilisation de modèles complexes.

1. Optimisation du démarrage à froid et gestion de la mémoire

Le démarrage à froid (cold start) est le principal ennemi des performances des applications serverless. Avec TypeScript, ce problème est aggravé par l'étape de compilation. Examinons trois méthodes principales pour y remédier.

1.1. Réduction de la taille du package de déploiement

Utilisez esbuild pour la compilation au lieu du tsc standard. Il effectue le tree-shaking et la minification, ce qui réduit la taille du bundle de 5 à 10 fois. Exemple de configuration pour serverless.yml :

plugins:\n  - serverless-esbuild\ncustom:\n  esbuild:\n    bundle: true\n    minify: true\n    sourcemap: false\n    target: 'node18'\n    exclude: ['aws-sdk'] # Le SDK est déjà présent dans l'environnement Lambda

1.2. Utilisation de Provisioned Concurrency

Pour les fonctions critiques en termes de latence (par exemple, traitant des requêtes API), configurez Provisioned Concurrency. Cela maintient un nombre défini de conteneurs "chauds" constamment actifs :

functions:\n  apiHandler:\n    handler: src/handler.apiHandler\n    provisionedConcurrency: 5 # Toujours 5 instances prêtes

1.3. Optimisation des imports et du code

Évitez les bibliothèques "lourdes" à l'intérieur de la fonction. Par exemple, au lieu d'importer aws-sdk v3 en entier, importez uniquement les clients nécessaires :

// Mauvais : import * as AWS from 'aws-sdk';\n// Bon :\nimport { DynamoDBClient } from '@aws-sdk/client-dynamodb';\nimport { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';

2. Travail avec Lambda Layers et les dépendances

Les Lambda Layers permettent d'extraire le code commun et les dépendances (par exemple, ORM, validateurs) en dehors de la fonction. Cela accélère le déploiement et réduit la taille de chaque package individuel.

2.1. Création d'une couche avec des utilitaires communs

La structure du projet peut ressembler à ceci :

project/\n├── layers/\n│   └── common/\n│       └── nodejs/\n│           ├── package.json\n│           └── node_modules/\n├── functions/\n│   ├── createUser.ts\n│   └── getUser.ts\n└── serverless.yml

Dans serverless.yml, nous connectons la couche :

layers:\n  commonLibs:\n    path: layers/common\n    compatibleRuntimes:\n      - nodejs18.x\nfunctions:\n  createUser:\n    handler: functions/createUser.handler\n    layers:\n      - { Ref: CommonLibsLambdaLayer }

2.2. Typage pour les couches

Pour que TypeScript "voie" les types de la couche, créez un tsconfig.json avec des chemins :

{\n  "compilerOptions": {\n    "paths": {\n      "@common/*": ["layers/common/nodejs/*"]\n    }\n  }\n}

Maintenant, dans la fonction, vous pouvez écrire :

import { validateEmail } from '@common/validators';

3. Travail avec VPC et sécurité

Les fonctions Lambda fonctionnant à l'intérieur d'un VPC perdent l'accès à l'internet public (sauf si une passerelle NAT est configurée). Cela est critique pour la connexion à RDS, ElastiCache ou des API privées.

3.1. Configuration de Lambda dans un VPC

Configuration via serverless.yml :

provider:\n  vpc:\n    securityGroupIds:\n      - sg-12345\n    subnetIds:\n      - subnet-abc\n      - subnet-def\n\nfunctions:\n  dbHandler:\n    handler: src/db.handler\n    vpc: true # hérite des paramètres du fournisseur

3.2. Modèle "Thin Handler" pour les connexions

L