Saltearse al contenido

Funciones Lambda de Python

El generador de Funciones Lambda en Python permite añadir una función lambda a un proyecto existente de Python.

Este generador crea un nuevo manejador de lambda en Python con configuración de infraestructura usando AWS CDK o Terraform. El backend generado utiliza AWS Lambda para implementación sin servidor, con opción de seguridad de tipos usando el Parser de AWS Lambda Powertools. Configura AWS Lambda Powertools para observabilidad, incluyendo registro, trazado con AWS X-Ray y métricas de CloudWatch.

Puedes generar una nueva función Lambda de dos formas:

  1. Instale el Nx Console VSCode Plugin si aún no lo ha hecho
  2. Abra la consola Nx en VSCode
  3. Haga clic en Generate (UI) en la sección "Common Nx Commands"
  4. Busque @aws/nx-plugin - py#lambda-function
  5. Complete los parámetros requeridos
    • Haga clic en Generate
    Parámetro Tipo Predeterminado Descripción
    project Requerido string - The project to add the lambda function to
    functionName Requerido 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.

    El generador añadirá los siguientes archivos a tu proyecto:

    • Directory<module-name>
      • <lambda-function>.py Implementación de la función

    Si se provee la opción functionPath, el generador añadirá los archivos necesarios en la ruta especificada:

    • Directory<module-name>
      • Directory<custom-path>
        • <function-name>.py Implementación de la función

    Dado que este generador proporciona infraestructura como código basada en tu proveedor de iacProvider seleccionado, creará un proyecto en packages/common que incluye los constructos CDK o módulos de Terraform correspondientes.

    El proyecto común de infraestructura como código tiene la siguiente estructura:

    • Directorypackages/common/constructs
      • Directorysrc
        • Directoryapp/ Constructos para infraestructura específica de un proyecto/generador
        • Directorycore/ Constructos genéricos reutilizados por los constructos en app
        • index.ts Punto de entrada que exporta los constructos de app
      • project.json Objetivos de compilación y configuración del proyecto

    El generador crea infraestructura como código para desplegar tu función según el iacProvider seleccionado:

    El generador crea constructos CDK para desplegar tu función, ubicados en el directorio packages/common/constructs.

    La implementación principal está en <function-name>.py. Aquí un ejemplo:

    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

    El generador configura automáticamente:

    1. Integración con AWS Lambda Powertools para observabilidad
    2. Recolección de métricas
    3. Seguridad de tipos usando @event_parser

    El generador configura registro estructurado usando AWS Lambda Powertools.

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

    El logger incluye automáticamente:

    • Solicitudes de eventos
    • Información del contexto Lambda
    • Indicadores de cold start

    El trazado con AWS X-Ray se configura automáticamente. Puedes añadir subsegmentos personalizados:

    def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    # Crea un nuevo subsegmento
    with tracer.provider.in_subsegment("function-subsegment"):
    # Tu lógica aquí
    return ....

    Las métricas de CloudWatch se recogen automáticamente. Puedes añadir métricas personalizadas:

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

    Métricas por defecto incluyen:

    • Conteo de invocaciones
    • Conteo de éxitos/fallos
    • Métricas de cold start

    Si elegiste un eventSource al generar tu función, esta se instrumenta con @event_parser de AWS Lambda Powertools. Por ejemplo:

    @event_parser(model=EventBridgeModel)
    def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    event.detail_type # <- tipado seguro con autocompletado IDE

    Esto permite definir modelos de datos usando Pydantic, similar a trabajar con Fast API.

    Si no deseas tipar tu evento, selecciona Any como eventSource.

    El generador configura automáticamente el empaquetado Python para paquetes de despliegue Lambda usando uv:

    Terminal window
    pnpm nx run <project-name>:bundle

    El proceso usa:

    1. uv export para exportar dependencias a requirements.txt
    2. uv pip install para instalar dependencias para la plataforma objetivo (x86_64-manylinux2014)

    Este generador crea infraestructura como código de CDK o Terraform según el iacProvider seleccionado. Puedes usarlo para implementar tu función.

    Este generador crea un constructo de CDK para implementar tu función en la carpeta common/constructs. Puedes usarlo en una aplicación de CDK:

    import { MyProjectMyFunction } from ':my-scope/common-constructs';
    export class ExampleStack extends Stack {
    constructor(scope: Construct, id: string) {
    // Agrega la función a tu stack
    const fn = new MyProjectMyFunction(this, 'MyFunction');
    }
    }

    Esto configura:

    1. Función AWS Lambda
    2. Grupo de logs de CloudWatch
    3. Configuración de trazado X-Ray
    4. Namespace de métricas en CloudWatch

    Esta función puede usarse como destino para cualquier origen de eventos de Lambda:

    El siguiente ejemplo muestra el código CDK para invocar tu función Lambda en un horario programado usando 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) {
    // Agrega la función a tu stack
    const fn = new MyProjectMyFunction(this, 'MyFunction');
    // Agrega la función a una regla programada de EventBridge
    const eventRule = new Rule(this, 'MyFunctionScheduleRule', {
    schedule: Schedule.cron({ minute: '15' }),
    targets: [new LambdaFunction(fn)],
    });
    }
    }