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à.
# Supporto Rust per le istanze gestite Lambda
## Configurazione della concorrenza
Il numero massimo di richieste simultanee che Lambda invia a ciascun ambiente di esecuzione è controllato dall'`PerExecutionEnvironmentMaxConcurrency`impostazione nella configurazione della funzione. Questa è un'impostazione opzionale e il valore predefinito per Rust è 8 richieste simultanee per vCPU, oppure puoi configurare il tuo valore. Questo valore determina il numero di task Tokio generati dal runtime ed è statico per tutta la durata dell'ambiente di esecuzione. Ogni lavoratore gestisce esattamente una richiesta in corso alla volta, senza multiplexing per lavoratore. Lambda regola automaticamente il numero di richieste simultanee fino al numero massimo configurato in base alla capacità di ciascun ambiente di esecuzione di assorbire tali richieste.
## Creazione di funzioni per la multi-concorrenza
È necessario applicare le stesse pratiche di sicurezza dei thread quando si utilizzano le istanze gestite Lambda come si farebbe in qualsiasi altro ambiente multithread. Poiché l'oggetto handler è condiviso su tutti i thread di lavoro, qualsiasi stato mutabile deve essere thread-safe. Ciò include raccolte, connessioni al database e qualsiasi oggetto statico modificato durante l'elaborazione delle richieste.
Per abilitare la gestione simultanea delle richieste, aggiungi il flag di `concurrency-tokio` funzionalità al tuo `Cargo.toml` file.
```
[dependencies]
lambda_runtime = { version = "1", features = ["concurrency-tokio"] }
```
Il punto di `lambda_runtime::run_concurrent(…)` ingresso deve essere chiamato dall'interno di un runtime di Tokio, in genere fornito dall'`#[tokio::main]`attributo sulla funzione principale. La chiusura del gestore deve implementare [ Clone ](https://doc.rust-lang.org/std/clone/trait.Clone.html) \+ Send. [https://doc.rust-lang.org/std/marker/trait.Send.html](https://doc.rust-lang.org/std/marker/trait.Send.html) Ciò consente al framework di condividere il gestore tra più attività asincrone in modo sicuro. Se questi limiti non vengono soddisfatti, il codice non verrà compilato.
Quando hai bisogno di uno stato condiviso tra le invocazioni (un pool di database, una struttura di configurazione), racchiudilo in [ Arc ](https://doc.rust-lang.org/std/sync/struct.Arc.html) e clonalo in ogni chiamata. `Arc`
Tutti i client AWS SDK per Rust sono conformi alla concorrenza e non richiedono una gestione speciale.
### Esempio: AWS Client SDK
L'esempio seguente utilizza un client S3 per caricare un oggetto su ogni chiamata. Il client viene clonato direttamente nella chiusura senza: `Arc`
```
let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
let s3_client = aws_sdk_s3::Client::new(&config);
run_concurrent(service_fn(move |event: LambdaEvent| {
let s3_client = s3_client.clone(); // cheap clone, no Arc needed
async move {
s3_client.put_object()
.bucket(&event.payload.bucket)
.key(&event.payload.key)
.body(event.payload.body.into_bytes().into())
.send()
.await?;
Ok(Response { message: "uploaded".into() })
}
}))
.await
```
### Esempio: pool di connessioni al database
Quando il gestore ha bisogno di accedere a uno stato condiviso, ad esempio un client e una configurazione, inseriscilo in [ Arc ](https://doc.rust-lang.org/std/sync/struct.Arc.html) e clonali `Arc` in ogni chiamata:
```
#[derive(Debug)]
struct AppState {
dynamodb_client: DynamoDbClient,
table_name: String,
cache_ttl: Duration,
}
let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
let state = Arc::new(AppState {
dynamodb_client: DynamoDbClient::new(&config),
table_name: std::env::var("TABLE_NAME").expect("TABLE_NAME must be set"),
cache_ttl: Duration::from_secs(300),
});
run_concurrent(service_fn(move |event: LambdaEvent| {
let state = state.clone();
async move { handle(event, state).await }
}))
.await
```
## Cartella condivisa /tmp
La `/tmp` directory è condivisa tra tutte le chiamate simultanee nello stesso ambiente di esecuzione. Utilizza nomi di file univoci per chiamata (ad esempio, includi l'ID della richiesta) o implementa il blocco esplicito dei file per evitare il danneggiamento dei dati.
## Registrazione dei log
L'interlacciamento dei log (voci di log provenienti da richieste diverse che vengono interlacciate nei log) è normale nei sistemi con più concorrenti. Le funzioni che utilizzano Lambda Managed Instances supportano il formato di log JSON strutturato tramite i controlli di registrazione avanzati di Lambda. [Configurazione dei controlli di registrazione avanzati per le funzioni Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced) Questo formato include il`requestId`, che consente di correlare le voci di registro a una singola richiesta. Per ulteriori informazioni, vedere[Registrazione avanzata con la cassa Tracing](rust-logging.md#rust-logging-tracing).
## Contesto della richiesta
L'`Context`oggetto viene passato direttamente a ogni chiamata del gestore. `event.context.request_id`Da utilizzare per accedere all'ID della richiesta corrente.
`event.context.xray_trace_id`Usare per accedere all'ID di X-Ray tracciamento. Lambda non supporta la variabile di `_X_AMZN_TRACE_ID` ambiente con Lambda Managed Instances. L'ID di X-Ray traccia viene propagato automaticamente quando si utilizza l'SDK per Rust. AWS
Utilizzato `event.context.deadline` per rilevare i timeout: contiene la scadenza di richiamo in millisecondi.
## Inizializzazione e spegnimento
L'inizializzazione della funzione avviene una volta per ambiente di esecuzione. Gli oggetti creati durante l'inizializzazione vengono condivisi tra le richieste.
Per le funzioni Lambda con estensioni, l'ambiente di esecuzione emette un segnale SIGTERM durante l'arresto. Questo segnale viene utilizzato dalle estensioni per attivare attività di pulizia, come lo svuotamento dei buffer. `lambda_runtime`offre un aiuto per semplificare la configurazione di una corretta gestione del segnale di spegnimento, spawn\_graceful\_shutdown\_handler (). [https://docs.rs/lambda_runtime/latest/lambda_runtime/fn.spawn_graceful_shutdown_handler.html](https://docs.rs/lambda_runtime/latest/lambda_runtime/fn.spawn_graceful_shutdown_handler.html) Per ulteriori informazioni sul ciclo di vita dell'ambiente di esecuzione, consulta [Comprendere il ciclo di vita dell’ambiente di esecuzione Lambda](lambda-runtime-environment.md).
## Versioni di dipendenza
Lambda Managed Instances richiede la seguente versione minima del pacchetto:
+ `lambda_runtime`: versione 1.1.1 o successiva, con la funzionalità abilitata `concurrency-tokio`
+ La versione minima supportata di Rust (MSRV) è 1.84.0.