# Hooks de runtime do Lambda SnapStart para Python
<a name="snapstart-runtime-hooks-python"></a>

É possível usar hooks de runtime para implementar o código antes que o Lambda crie um snapshot ou depois que o Lambda retorna uma função de um snapshot. Os hooks de runtime do Python estão disponíveis como parte da biblioteca de código aberto [Snapshot Restore for Python](https://pypi.org/project/snapshot-restore-py/), que está incluída nos runtimes gerenciados do Python. Essa biblioteca fornece dois decoradores que você pode usar para definir seus hooks de runtime:
+ `@register_before_snapshot`: para funções que você deseja executar antes de o Lambda criar um snapshot.
+ `@register_after_restore`: para funções que você deseja executar quando o Lambda retoma uma função de um snapshot.

Como alternativa, você pode usar os seguintes métodos para registrar objetos que podem ser chamados em hooks de runtime:
+ `register_before_snapshot(func, *args, **kwargs)`
+ `register_after_restore(func, *args, **kwargs)`

## Registro e execução do hook de runtime
<a name="runtime-hooks-registration-python"></a>

A ordem em que o Lambda executa seus hooks de runtime é determinada pela ordem de registro:
+ Antes do snapshot: executado na ordem inversa do registro
+ Após o snapshot: executado na ordem de registro

A ordem do registro de hooks de runtime depende de como você define os hooks. Ao usar decoradores (`@register_before_snapshot` e `@register_after_restore`), a ordem de registro segue a ordem de importação, definição ou execução em seu código. Se você precisar de mais controle sobre a ordem de registro, use os métodos `register_before_snapshot()` e `register_after_restore()`, em vez de decoradores.

Certifique-se de que todos os hooks registrados sejam importados e incluídos corretamente no código da sua função. Se você registrar hooks de runtime em um arquivo ou módulo separado, deverá garantir que o módulo seja importado, diretamente ou como parte de um pacote maior, no arquivo do manipulador da sua função. Se o arquivo ou módulo não for importado no manipulador da função, o Lambda vai ignorar os hooks de runtime.

**nota**  
Quando o Lambda cria um snapshot, o código de inicialização pode ser executado por até 15 minutos. O limite de tempo é de 130 segundos ou o [tempo limite da função configurada](configuration-timeout.md) (máximo de 900 segundos), o que for maior. Seus hooks de runtime de `@register_before_snapshot` contam até o limite de tempo do código de inicialização. Quando o Lambda restaura um snapshot, o runtime deve ser carregado e os hooks de runtime `@register_after_restore` devem ser concluídos dentro do limite de tempo limite (dez segundos). Caso contrário, você obterá uma SnapStartTimeoutException.

## Exemplo
<a name="runtime-hooks-python-code-sample"></a>

O manipulador exemplificado a seguir mostra como executar o código antes do ponto de verificação (`@register_before_snapshot`) e depois da restauração (`@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
```

Para conferir mais exemplos, consulte [Snapshot Restore for Python](https://github.com/aws/snapshot-restore-py/tree/main/examples) no repositório do GitHub da AWS.