Fonctions Lambda Python

Le générateur de fonction Lambda Python permet d’ajouter une fonction lambda à un projet Python existant.

Ce générateur crée un nouveau gestionnaire Lambda Python avec une infrastructure AWS CDK ou Terraform. Le backend généré utilise AWS Lambda pour un déploiement serverless, avec une validation de types optionnelle via le Parser d’AWS Lambda Powertools. Il configure AWS Lambda Powertools pour l’observabilité, incluant le logging, le tracing AWS X-Ray et les métriques CloudWatch.

Utilisation

Générer une fonction Lambda

Vous pouvez générer une nouvelle fonction Lambda de deux manières :

VSCode

1. Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
2. Ouvrez la console Nx dans VSCode
3. Cliquez sur Generate (UI) dans la section "Common Nx Commands"
4. Recherchez @aws/nx-plugin - py#lambda-function
5. Remplissez les paramètres requis
6. Cliquez sur Generate

CLI

pnpm

pnpm nx g @aws/nx-plugin:py#lambda-function

yarn

yarn nx g @aws/nx-plugin:py#lambda-function

npm

npx nx g @aws/nx-plugin:py#lambda-function

bun

bunx nx g @aws/nx-plugin:py#lambda-function

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm

pnpm nx g @aws/nx-plugin:py#lambda-function --dry-run

yarn

yarn nx g @aws/nx-plugin:py#lambda-function --dry-run

npm

npx nx g @aws/nx-plugin:py#lambda-function --dry-run

bun

bunx nx g @aws/nx-plugin:py#lambda-function --dry-run

Options

Paramètre	Type	Par défaut	Description
project Requis	string	-	The project to add the lambda function to
functionName Requis	string	-	The name of the function to add
functionPath	string	-	The path within the project source directory to add the function to
eventSource	string	Any	Optional event source model to use for the lambda function
iacProvider	string	Inherit	The preferred IaC provider. By default this is inherited from your initial selection.

Résultat du générateur

Le générateur ajoutera les fichiers suivants à votre projet :

• Répertoire<module-name>

  • <lambda-function>.py Implémentation de la fonction

Si l’option functionPath est fournie, le générateur ajoutera les fichiers nécessaires au chemin spécifié :

• Répertoire<module-name>

  • Répertoire<custom-path>

    • <function-name>.py Implémentation de la fonction

Infrastructure

Ce générateur fournit de l’infrastructure as code basée sur votre iacProvider choisi. Il créera un projet dans packages/common qui inclut les constructions CDK ou modules Terraform pertinents.

Le projet commun d’infrastructure as code est structuré comme suit :

CDK

• Répertoirepackages/common/constructs

  • Répertoiresrc

    • Répertoireapp/ Constructions pour l’infrastructure spécifique à un projet/générateur

      • …
    • Répertoirecore/ Constructions génériques réutilisées par celles dans app

      • …
    • index.ts Point d’entrée exportant les constructions depuis app
  • project.json Cibles de build et configuration du projet

Note

Ce projet est généré avec le générateur ts#project et configure donc les mêmes cibles de build.

Terraform

• Répertoirepackages/common/terraform

  • Répertoiresrc

    • Répertoireapp/ Modules Terraform pour l’infrastructure spécifique à un projet/générateur

      • …
    • Répertoirecore/ Modules génériques réutilisés par ceux dans app

      • …
  • project.json Cibles de build et configuration du projet

Note

Ce projet est généré avec le générateur terraform#project et configure donc les mêmes cibles de build.

Le générateur crée une infrastructure as code pour déployer votre fonction selon le iacProvider sélectionné :

CDK

Le générateur crée des constructs CDK utilisables pour déployer votre fonction, situés dans le répertoire packages/common/constructs.

Terraform

Le générateur crée un module Terraform utilisable pour déployer votre fonction, situé dans le répertoire packages/common/terraform/src/app/lambda-functions/<function-name>.

Implémentation de votre fonction

L’implémentation principale se trouve dans <function-name>.py. Voici un exemple :

import os

from aws_lambda_powertools import Logger, Metrics, Tracer
from aws_lambda_powertools.metrics import MetricUnit
from aws_lambda_powertools.utilities.parser import event_parser
from aws_lambda_powertools.utilities.parser.models import EventBridgeModel
from aws_lambda_powertools.utilities.typing import LambdaContext

os.environ["POWERTOOLS_METRICS_NAMESPACE"] = "Foo"
os.environ["POWERTOOLS_SERVICE_NAME"] = "Foo"

logger: Logger = Logger()
metrics: Metrics = Metrics()
tracer: Tracer = Tracer()

@tracer.capture_lambda_handler
@metrics.log_metrics
@event_parser(model=EventBridgeModel)
def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    logger.info("Received event", extra={"event": event.model_dump() })
    metrics.add_metric(name="InvocationCount", unit=MetricUnit.Count, value=1)

    try:
        # TODO: Implement
        metrics.add_metric(name="SuccessCount", unit=MetricUnit.Count, value=1)
        # TODO: Implement success response if required
    except Exception as e:
        logger.exception(e)
        metrics.add_metric(name="ErrorCount", unit=MetricUnit.Count, value=1)
        # TODO: Implement error response if required

Le générateur configure automatiquement plusieurs fonctionnalités :

1. Intégration d’AWS Lambda Powertools pour l’observabilité
2. Collecte de métriques
3. Validation de types avec @event_parser

Observabilité avec AWS Lambda Powertools

Journalisation

Le générateur configure la journalisation structurée avec AWS Lambda Powertools.

def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    logger.info("Received event", extra={"event": event.model_dump()})

Astuce

Il est recommandé de définir un ID de corrélation pour toutes les requêtes uniques afin de faciliter le débogage et le monitoring. Consultez la documentation aws powertools logger pour les bonnes pratiques.

Le logger inclut automatiquement :

• Les requêtes d’événements
• Les informations de contexte Lambda
• Les indicateurs de cold start

Tracing

Le tracing AWS X-Ray est configuré automatiquement. Vous pouvez ajouter des sous-segments personnalisés :

def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    # Crée un nouveau sous-segment
    with tracer.provider.in_subsegment("function-subsegment"):
        # Votre logique ici
        return ....

Métriques

Les métriques CloudWatch sont collectées automatiquement pour chaque requête. Vous pouvez ajouter des métriques personnalisées :

def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    metrics.add_metric(name="NewMetric", unit=MetricUnit.Count, value=1)
    return ...

Les métriques par défaut incluent :

• Nombre d’invocations
• Taux de succès/échec
• Métriques de cold start

Validation de types

Si vous avez choisi un eventSource lors de la génération, votre fonction est instrumentée avec @event_parser d’AWS Lambda Powertools. Exemple :

@event_parser(model=EventBridgeModel)
def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    event.detail_type # <- typage fort avec autocomplétion IDE

Ceci permet de définir des modèles de données avec Pydantic, similaire à Fast API.

Astuce

Pour des données personnalisées dans des événements (ex: flux DynamoDB ou EventBridge), utilisez Envelopes pour assurer le typage.

Si vous ne souhaitez pas typer votre événement, sélectionnez Any comme eventSource.

Bundling

Le générateur configure automatiquement le packaging Python pour les déploiements Lambda avec uv :

pnpm

pnpm nx run <project-name>:bundle

yarn

yarn nx run <project-name>:bundle

npm

npx nx run <project-name>:bundle

bun

bunx nx run <project-name>:bundle

Note

Ceci package l’intégralité du projet. Pour réduire la taille, vous pouvez séparer les fonctions dans plusieurs projets Python générés avec py#project.

Ce processus utilise :

1. uv export pour exporter les dépendances dans requirements.txt
2. uv pip install pour installer les dépendances pour la plateforme cible (x86_64-manylinux2014)

Note

Si vous utilisez une architecture ARM, modifiez la cible de bundling en aarch64-manylinux2014.

Déploiement de votre fonction

Ce générateur crée une infrastructure CDK ou Terraform sous forme de code en fonction du iacProvider sélectionné. Vous pouvez l’utiliser pour déployer votre fonction.

CDK

Ce générateur crée un construct CDK pour déployer votre fonction dans le dossier common/constructs. Vous pouvez l’utiliser dans une application CDK :

import { MyProjectMyFunction } from ':my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    // Ajoute la fonction à votre stack
    const fn = new MyProjectMyFunction(this, 'MyFunction');
  }
}

Ceci configure :

1. Une fonction AWS Lambda
2. Un groupe de logs CloudWatch
3. La configuration du tracing X-Ray
4. Un espace de noms pour les métriques CloudWatch

Cette fonction peut ensuite être utilisée comme cible pour n’importe quelle source d’événement lambda :

Note

Vérifiez que la source d’événement correspond à l’option eventSource sélectionnée pour garantir un traitement correct des événements dans votre fonction de gestion.

L’exemple ci-dessous montre le code CDK pour invoquer votre fonction lambda selon un calendrier avec EventBridge :

import { Rule, Schedule } from 'aws-cdk-lib/aws-events';
import { LambdaFunction } from 'aws-cdk-lib/aws-events-targets';
import { MyProjectMyFunction } from ':my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    // Ajoute la fonction à votre stack
    const fn = new MyProjectMyFunction(this, 'MyFunction');

    // Ajoute la fonction à une règle planifiée EventBridge
    const eventRule = new Rule(this, 'MyFunctionScheduleRule', {
      schedule: Schedule.cron({ minute: '15' }),
      targets: [new LambdaFunction(fn)],
    });
  }
}

Terraform

Ce générateur crée un module Terraform pour déployer votre fonction dans le dossier common/terraform. Vous pouvez l’utiliser dans une configuration Terraform :

module "my_project_my_function" {
  source = "../../common/terraform/src/app/lambda-functions/my-project-my-function"

  # Variables d'environnement pour la fonction Lambda
  env = {
    SOME_VARIABLE = "some value"
  }

  # Politiques IAM supplémentaires si nécessaire
  additional_iam_policy_statements = [
    # Ajoutez les permissions supplémentaires requises
  ]
}

Ceci configure :

1. Une fonction AWS Lambda
2. Un groupe de logs CloudWatch
3. La configuration du tracing X-Ray
4. Un espace de noms pour les métriques CloudWatch

Cette fonction peut ensuite être utilisée comme cible pour n’importe quelle source d’événement lambda. L’exemple ci-dessous montre le code Terraform pour invoquer votre fonction lambda selon un calendrier avec EventBridge :

# Règle EventBridge pour exécution planifiée
resource "aws_cloudwatch_event_rule" "my_function_schedule" {
  name                = "my-function-schedule"
  description         = "Déclenche la fonction toutes les 15 minutes"
  schedule_expression = "cron(15 * * * ? *)"
}

# Cible EventBridge
resource "aws_cloudwatch_event_target" "lambda_target" {
  rule      = aws_cloudwatch_event_rule.my_function_schedule.name
  target_id = "MyFunctionTarget"
  arn       = module.my_project_my_function.function_arn
}

# Permission pour EventBridge d'invoquer la fonction Lambda
resource "aws_lambda_permission" "allow_eventbridge" {
  statement_id  = "AllowExecutionFromEventBridge"
  action        = "lambda:InvokeFunction"
  function_name = module.my_project_my_function.function_name
  principal     = "events.amazonaws.com"
  source_arn    = aws_cloudwatch_event_rule.my_function_schedule.arn
}

Note

Vérifiez que la source d’événement correspond à l’option eventSource sélectionnée pour garantir un traitement correct des événements dans votre fonction de gestion.