Lambda SnapStart runtime hooks for Python - AWS Lambda
Registration and executionExample

Lambda SnapStart runtime hooks for Python

You can use runtime hooks to implement code before Lambda creates a snapshot or after Lambda resumes a function from a snapshot. Python runtime hooks are available as part of the open-source Snapshot Restore for Python library, which is included in Python managed runtimes. This library provides two decorators that you can use to define your runtime hooks:

  • @register_before_snapshot: For functions you want to run before Lambda creates a snapshot.

  • @register_after_restore: For functions you want to run when Lambda resumes a function from a snapshot.

Alternatively, you can use the following methods to register callables for runtime hooks:

  • register_before_snapshot(func, *args, **kwargs)

  • register_after_restore(func, *args, **kwargs)

Runtime hook registration and execution

The order that Lambda executes your runtime hooks is determined by the order of registration:

  • Before snapshot: Executed in the reverse order of registration

  • After snapshot: Executed in the order of registration

The order of runtime hook registration depends on how you define the hooks. When using decorators (@register_before_snapshot and @register_after_restore), the registration order follows the order of import, definition, or execution in your code. If you need more control over the registration order, use the register_before_snapshot() and register_after_restore() methods instead of decorators.

Make sure that all registered hooks are properly imported and included in your function's code. If you register runtime hooks in a separate file or module, you must ensure that the module is imported, either directly or as part of a larger package, in your function's handler file. If the file or module is not imported in the function handler, Lambda ignores the runtime hooks.

Note

When Lambda creates a snapshot, your initialization code can run for up to 15 minutes. The time limit is 130 seconds or the configured function timeout (maximum 900 seconds), whichever is higher. Your @register_before_snapshot runtime hooks count towards the initialization code time limit. When Lambda restores a snapshot, the runtime must load and @register_after_restore runtime hooks must complete within the timeout limit (10 seconds). Otherwise, you'll get a SnapStartTimeoutException.

Example

The following example handler shows how to run code before checkpointing (@register_before_snapshot) and after restoring (@register_after_restore).

from snapshot_restore_py import register_before_snapshot, register_after_restore

def lambda_handler(event, context):
    # Handler code

@register_before_snapshot
def before_checkpoint():
    # Logic to be executed before taking snapshots

@register_after_restore
def after_restore():
    # Logic to be executed after restore

For more examples, see Snapshot Restore for Python in the AWS GitHub repository.