Python Lambda Functions

The Python Lambda Function generator provides the ability to add a lambda function to an existing python project.

This generator creates a new python lambda handler with AWS CDK or Terraform infrastructure setup. The generated backend uses AWS Lambda for serverless deployment, with optional type-safety using the Parser from AWS Lambda Powertools. It sets up AWS Lambda Powertools for observability, including logging, AWS X-Ray tracing and Cloudwatch Metrics.

Usage

Generate a Lambda Function

You can generate a new Lambda Function in two ways:

VSCode

1. Install the Nx Console VSCode Plugin if you haven't already
2. Open the Nx Console in VSCode
3. Click Generate (UI) in the "Common Nx Commands" section
4. Search for @aws/nx-plugin - py#lambda-function
5. Fill in the required parameters
6. Click 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

You can also perform a dry-run to see what files would be changed

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

Parameter	Type	Default	Description
project Required	string	-	The project to add the lambda function to
name Required	string	-	The name of the function to add
functionPath	string	-	The path within the project source directory to add the function to
event	Any | AlbModel | APIGatewayProxyEventModel | ApiGatewayAuthorizerToken | ApiGatewayAuthorizerRequest | APIGatewayProxyEventV2Model | ApiGatewayAuthorizerRequestV2 | APIGatewayWebSocketMessageEventModel | APIGatewayWebSocketConnectEventModel | APIGatewayWebSocketDisconnectEventModel | BedrockAgentEventModel | CloudFormationCustomResourceCreateModel | CloudFormationCustomResourceUpdateModel | CloudFormationCustomResourceDeleteModel | CloudwatchLogsModel | DynamoDBStreamModel | EventBridgeModel | IoTCoreThingEvent | IoTCoreThingTypeEvent | IoTCoreThingTypeAssociationEvent | IoTCoreThingGroupEvent | IoTCoreAddOrRemoveFromThingGroupEvent | IoTCoreAddOrDeleteFromThingGroupEvent | KafkaMskEventModel | KafkaSelfManagedEventModel | KinesisDataStreamModel | KinesisFirehoseModel | KinesisFirehoseSqsModel | LambdaFunctionUrlModel | S3BatchOperationModel | S3EventNotificationEventBridgeModel | S3Model | S3ObjectLambdaEvent | S3SqsEventNotificationModel | SesModel | SnsModel | SqsModel | TransferFamilyAuthorizer | VpcLatticeModel | VpcLatticeV2Model	Any	Optional event source model to use for the lambda function
infra	lambda | none	lambda	The type of infrastructure to deploy your Lambda function with.
iac	inherit | cdk | terraform	inherit	The preferred IaC provider. By default this is inherited from your initial selection.
preferInstallDependencies	boolean	true	Whether to prefer installing dependencies after the generator runs. Set to false to defer installing when batching multiple generators (an install still runs if needed so subsequent generators can compute the Nx project graph); install once at the end.

Generator Output

The generator will add the following files to your project:

• Directory<module-name>

  • <lambda-function>.py Function implementation

If the functionPath option is provided, the generater will add the necessary files to the specified path:

• Directory<module-name>

  • Directory<custom-path>

    • <function-name>.py Function implementation

Infrastructure

Since this generator vends infrastructure as code based on your chosen iacProvider, it will create a project in packages/common which includes the relevant CDK constructs or Terraform modules.

The common infrastructure as code project is structured as follows:

CDK

• Directorypackages/common/constructs

  • Directorysrc

    • Directoryapp/ Constructs for infrastructure specific to a project/generator

      • …
    • Directorycore/ Generic constructs which are reused by constructs in app

      • …
    • index.ts Entry point exporting constructs from app
  • project.json Project build targets and configuration

Generated Project

This project is generated using the ts#project generator and therefore configures the same build targets.

Terraform

• Directorypackages/common/terraform

  • Directorysrc

    • Directoryapp/ Terraform modules for infrastructure specific to a project/generator

      • …
    • Directorycore/ Generic modules which are reused by modules in app

      • …
  • project.json Project build targets and configuration

Generated Project

This project is generated using the terraform#project generator and therefore configures the same build targets.

The generator creates infrastructure as code for deploying your function based on your selected iacProvider:

CDK

The generator creates CDK constructs which can be used to deploy your function, which reside in the packages/common/constructs directory.

Terraform

The generator creates a Terraform module which can be used to deploy your function, which resides in the packages/common/terraform/src/app/lambda-functions/<function-name> directory.

Architecture

The deployed function has the following architecture:

The generator vends the function itself; you wire the event source up in your stack to invoke it (for example, an API Gateway integration, an EventBridge rule, an S3 notification or an SQS event source mapping).

Implementing your Function

The main function implementation is in <function-name>.py. Here’s an example:

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

The generator sets up several features automatically:

1. AWS Lambda Powertools integration for observability
2. Metrics collection
3. Type-safety using @event_parser

Observability with AWS Lambda Powertools

Logging

The generator configures structured logging using AWS Lambda Powertools.

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

Correlation ID

It is recommended to set the correlation id for all unique requests for easier debugging and monitoring. Please refer to the aws powertools logger documentation for correlation id best practices.

The logger automatically includes:

• Event requests
• Lambda context information
• Cold start indicators

Tracing

AWS X-Ray tracing is configured automatically. You can add custom subsegments to your traces:

def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    # Creates a new subsegment
    with tracer.provider.in_subsegment("function-subsegment"):
        # Your logic here
        return ....

Metrics

CloudWatch metrics are collected automatically for each request. You can add custom metrics:

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

Default metrics include:

• Invocation counts
• Success/failure counts
• Cold start metrics

Type Safety

event ≠ Any

If you chose an event when generating your lambda function, your function is instrumented with @event_parser from AWS Lambda Powertools. For example:

@event_parser(model=EventBridgeModel)
def lambda_handler(event: EventBridgeModel, context: LambdaContext):
    event.detail_type # <- type-safe with IDE autocompletion

This allows you to define data models using Pydantic, in a similar manner to working with Fast API.

Custom Event Data

If you have custom data nested within an event, for example a DynamoDB stream or EventBridge event, you may benefit from using Envelopes to provide type-safety for that custom data.

event = Any

If you selected Any for your event, the @event_parser decorator is not applied and the handler receives an untyped event dict. Regenerate with a specific event if you want Pydantic validation and typed field access.

Bundling

The generator automatically configures Python bundling for Lambda deployment packages using uv:

pnpm

pnpm nx bundle <project-name>

yarn

yarn nx bundle <project-name>

npm

npx nx bundle <project-name>

bun

bunx nx bundle <project-name>

Bundle Behavior

This bundles the whole project as the deployment package. To minimise deployment size, you may wish to split multiple lambda functions over multiple Python projects generated with the py#project generator.

This process uses:

1. uv export to export your Python dependencies to a requirements.txt file
2. uv pip install to install dependencies for the target platform (x86_64-manylinux_2_28) for Lambda deployment

Architecture Changes

If you change your lambda architecture to ARM, you will need to edit your bundle target to use the aarch64-manylinux_2_28 target.

Deploying your Function

This generator creates CDK or Terraform infrastructure as code based on your selected iacProvider. You can use this to deploy your function.

CDK

This generator creates a CDK construct for deploying your function in the common/constructs folder. You can use this in a CDK application:

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

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    // Add the function to your stack
    const fn = new MyProjectMyFunction(this, 'MyFunction');
  }
}

This sets up:

1. AWS Lambda function
2. CloudWatch log group
3. X-Ray tracing configuration
4. CloudWatch metrics namespace

This function can then be used as a target for any lambda event source:

Event Source Matching

Ensure the event source matches the selected event option to ensure the event is properly handled within your handler function.

The example below demonstrates the CDK code for invoking your lambda function on a schedule using 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) {
    // Add the function to your stack
    const fn = new MyProjectMyFunction(this, 'MyFunction');

    // Add the function to an EventBridge scheduled rule
    const eventRule = new Rule(this, 'MyFunctionScheduleRule', {
      schedule: Schedule.cron({ minute: '15' }),
      targets: [new LambdaFunction(fn)],
    });
  }
}

Terraform

This generator creates a Terraform module for deploying your function in the common/terraform folder. Instantiate the shared core/asset-bucket module once per deployment and pass its bucket_name into the asset_bucket_name input:

module "asset_bucket" {
  source = "../../common/terraform/src/core/asset-bucket"
}

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

  asset_bucket_name = module.asset_bucket.bucket_name

  env = {
    SOME_VARIABLE = "some value"
  }

  additional_iam_policy_statements = [
    # Add any additional permissions your function needs
  ]
}

This sets up:

1. AWS Lambda function
2. CloudWatch log group
3. X-Ray tracing configuration
4. CloudWatch metrics namespace

This function can then be used as a target for any lambda event source. The example below demonstrates the Terraform code for invoking your lambda function on a schedule using EventBridge:

# EventBridge rule for scheduled execution
resource "aws_cloudwatch_event_rule" "my_function_schedule" {
  name                = "my-function-schedule"
  description         = "Trigger my function every 15 minutes"
  schedule_expression = "cron(15 * * * ? *)"
}

# EventBridge target
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 for EventBridge to invoke the Lambda function
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
}

Event Source Matching

Ensure the event source matches the selected event option to ensure the event is properly handled within your handler function.