Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Hook di runtime SnapStart per Lambda per Python
<a name="snapstart-runtime-hooks-python"></a>

Gli hook di runtime possono essere utilizzati per implementare il codice prima che Lambda crei uno snapshot o dopo che ha ripristinato una funzione da uno snapshot. Gli hook di runtime Python sono disponibili come parte della libreria open source [Snapshot Restore for Python](https://pypi.org/project/snapshot-restore-py/), che è inclusa nei runtime gestiti da Python. Questa libreria fornisce due decoratori che possono essere utilizzati per definire i tuoi hook di runtime:
+ `@register_before_snapshot`: per le funzioni che si desidera eseguire prima che Lambda crei uno snapshot.
+ `@register_after_restore`: per le funzioni che si desidera eseguire quando Lambda riprende una funzione da uno snapshot.

In alternativa, è possibile utilizzare i seguenti metodi per registrare gli elementi chiamabili per gli hook di runtime:
+ `register_before_snapshot(func, *args, **kwargs)`
+ `register_after_restore(func, *args, **kwargs)`

## Registrazione ed esecuzione di hook di runtime
<a name="runtime-hooks-registration-python"></a>

L'ordine in cui Lambda esegue gli hook di runtime è determinato dall'ordine di registrazione:
+ Prima dello snapshot: eseguito nell'ordine di registrazione inverso
+ Dopo lo snapshot: eseguito nell'ordine di registrazione

L'ordine di registrazione degli hook di runtime dipende da come vengono definiti gli hook. Quando si utilizzano i decoratori (`@register_before_snapshot` e `@register_after_restore`), l'ordine di registrazione segue l'ordine di importazione, definizione o esecuzione nel codice. Se hai bisogno di un maggiore controllo sull'ordine di registrazione, usa i metodi `register_before_snapshot()` e `register_after_restore()` anziché i decoratori.

Assicurati che tutti gli hook registrati siano stati importati e inclusi correttamente nel codice della tua funzione. Se registri gli hook di runtime in un file o modulo separato, dovrai assicurarti che il modulo venga importato, direttamente o come parte di un pacchetto più grande, nel file handler della funzione. Se il file o il modulo non viene importato nell'handler della funzione, Lambda ignorerà gli hook di runtime.

**Nota**  
Quando Lambda crea uno snapshot, il codice di inizializzazione può essere eseguito per un massimo di 15 minuti. Il limite di tempo è 130 secondi o il [timeout della funzione configurato](configuration-timeout.md) (massimo 900 secondi), a seconda di quale dei due valori sia più elevato. I tuoi hook di runtime `@register_before_snapshot` contano ai fini del limite di tempo del codice di inizializzazione. Quando Lambda ripristina uno snapshot, il runtime deve essere caricato e gli hook di runtime `@register_after_restore` devono essere completati entro il limite di timeout (10 secondi). Altrimenti, otterrai un'eccezione SnapStartTimeoutException.

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

Il seguente gestore di esempio mostra come eseguire il codice prima del checkpoint (`@register_before_snapshot`) e dopo il ripristino (`@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
```

Per altri esempi, consulta [Ripristino di snapshot per Python](https://github.com/aws/snapshot-restore-py/tree/main/examples) nel repository AWS GitHub.