lambda

class moto.awslambda.models.LambdaBackend(region_name: str, account_id: str)

Implementation of the AWS Lambda endpoint. Invoking functions is supported - they will run inside a Docker container, emulating the real AWS behaviour as closely as possible.

Warning

When invoking a function using the decorators, the created Docker container cannot reach Moto (or it’s in-memory state). Any AWS SDK-requests within your Lambda will try to connect to AWS instead.

It is possible to connect from AWS Lambdas to other services, as long as you are running MotoProxy or the MotoServer in a Docker container.

Moto injects the AWS_ENDPOINT_URL environment variable into every Lambda, which means that calls to other AWS services are automatically intercepted.

Note that, if you use a non-standard or older Docker image, the AWS_ENDPOINT_URL may not be supported.

If that is the case, use the environment variables MOTO_HOST and MOTO_PORT to build the AWS endpoint url and point it to Moto:

def lambda_handler(event, context):
    host = os.environ.get("MOTO_HOST")
    port = os.environ.get("MOTO_PORT")
    url = host + ":" + port
    ec2 = boto3.client('ec2', region_name='us-west-2', endpoint_url=url)

    # Or even simpler:
    full_url = os.environ.get("MOTO_HTTP_ENDPOINT")
    ec2 = boto3.client("ec2", region_name="eu-west-1", endpoint_url=full_url)

    ec2.do_whatever_inside_the_existing_moto_server()

Moto will run on port 5000 by default. This can be overwritten by setting an environment variable when starting Moto:

# This env var will be propagated to the Docker container running the Lambda functions
MOTO_PORT=5000 moto_server

The Docker container uses the default network mode, bridge. The following environment variables are available for fine-grained control over the Docker connection options:

# Provide the name of a custom network to connect to
MOTO_DOCKER_NETWORK_NAME=mycustomnetwork moto_server

# Override the network mode
# For example, network_mode=host would use the network of the host machine
# Note that this option will be ignored if MOTO_DOCKER_NETWORK_NAME is also set
MOTO_DOCKER_NETWORK_MODE=host moto_server

_-_-_-_

The Docker images used by Moto are taken from the following repositories:

shogo82148/lambda-python (for recent versions)
mlupin/docker-lambda (for older/outdated versions)
lambci/lambda (for even older/outdated versions)

Use the following environment variable to configure Moto to look for images in an additional repository:

MOTO_DOCKER_LAMBDA_IMAGE=mlupin/docker-lambda

_-_-_-_

Use the following environment variable if you want to configure the data directory used by the Docker containers:

MOTO_LAMBDA_DATA_DIR=/tmp/data

_-_-_-_

If you want to mock the Lambda-containers invocation without starting a Docker-container, use the simple decorator:

@mock_aws(config={"lambda": {"use_docker": False}})

Implemented features for this service

[X] add_layer_version_permission
[X] add_permission
[ ] checkpoint_durable_execution
[X] create_alias
[ ] create_capacity_provider
[ ] create_code_signing_config
[X] create_event_source_mapping
[X] create_function

The Code.ImageUri is not validated by default. Set environment variable MOTO_LAMBDA_STUB_ECR=false if you want to validate the image exists in our mocked ECR.

[X] create_function_url_config

The Qualifier-parameter is not yet implemented. Function URLs are not yet mocked, so invoking them will fail

[X] delete_alias
[ ] delete_capacity_provider
[ ] delete_code_signing_config
[X] delete_event_source_mapping
[X] delete_function
[ ] delete_function_code_signing_config
[X] delete_function_concurrency
[X] delete_function_event_invoke_config
[X] delete_function_url_config

The Qualifier-parameter is not yet implemented

[X] delete_layer_version
[ ] delete_provisioned_concurrency_config
[ ] get_account_settings
[X] get_alias
[ ] get_capacity_provider
[ ] get_code_signing_config
[ ] get_durable_execution
[ ] get_durable_execution_history
[ ] get_durable_execution_state
[X] get_event_source_mapping
[X] get_function
[X] get_function_code_signing_config
[X] get_function_concurrency
[ ] get_function_configuration
[X] get_function_event_invoke_config
[ ] get_function_recursion_config
[ ] get_function_scaling_config
[X] get_function_url_config

The Qualifier-parameter is not yet implemented

[X] get_layer_version
[ ] get_layer_version_by_arn
[X] get_layer_version_policy
[X] get_policy
[ ] get_provisioned_concurrency_config
[ ] get_runtime_management_config
[X] invoke

Invoking a Function with PackageType=Image is not yet supported.

Invoking a Function against Lambda without docker now supports customised responses, the default being Simple Lambda happy path OK. You can use a dedicated API to override this, by configuring a queue of expected results.

A request to invoke will take the first result from that queue.

Configure this queue by making an HTTP request to /moto-api/static/lambda-simple/response. An example invocation looks like this:

expected_results = {"results": ["test", "test 2"], "region": "us-east-1"}
resp = requests.post(
    "http://motoapi.amazonaws.com/moto-api/static/lambda-simple/response",
    json=expected_results
)
assert resp.status_code == 201

client = boto3.client("lambda", region_name="us-east-1")
resp = client.invoke(...) # resp["Payload"].read().decode() == "test"
resp = client.invoke(...) # resp["Payload"].read().decode() == "test2"

[ ] invoke_async
[ ] invoke_with_response_stream
[X] list_aliases
[ ] list_capacity_providers
[ ] list_code_signing_configs
[ ] list_durable_executions_by_function
[X] list_event_source_mappings
[X] list_function_event_invoke_configs
[ ] list_function_url_configs
[ ] list_function_versions_by_capacity_provider
[X] list_functions
[ ] list_functions_by_code_signing_config
[X] list_layer_versions
[X] list_layers
[ ] list_provisioned_concurrency_configs
[X] list_tags
[X] list_versions_by_function
[X] publish_layer_version
[X] publish_version
[ ] put_function_code_signing_config
[X] put_function_concurrency Establish concurrency limit/reservations for a function

Actual lambda restricts concurrency to 1000 (default) per region/account across all functions; we approximate that behavior by summing across all functions (hopefully all in the same account and region) and allowing the caller to simulate an increased quota.

By default, no quota is enforced in order to preserve compatibility with existing code that assumes it can do as many things as it likes. To model actual AWS behavior, define the MOTO_LAMBDA_CONCURRENCY_QUOTA environment variable prior to testing.

[X] put_function_event_invoke_config
[ ] put_function_recursion_config
[ ] put_function_scaling_config
[ ] put_provisioned_concurrency_config
[ ] put_runtime_management_config
[X] remove_layer_version_permission
[X] remove_permission
[ ] send_durable_execution_callback_failure
[ ] send_durable_execution_callback_heartbeat
[ ] send_durable_execution_callback_success
[ ] stop_durable_execution
[X] tag_resource
[X] untag_resource
[X] update_alias

The RevisionId parameter is not yet implemented

[ ] update_capacity_provider
[ ] update_code_signing_config
[X] update_event_source_mapping
[X] update_function_code
[X] update_function_configuration
[X] update_function_event_invoke_config
[X] update_function_url_config

The Qualifier-parameter is not yet implemented