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à.

# Configurazione degli intercettori nell'SDK per Rust AWS
<a name="interceptors"></a>

È possibile utilizzare gli intercettori per agganciarsi all'esecuzione di richieste e risposte API. Gli intercettori sono meccanismi aperti in cui l'SDK richiama il codice scritto dall'utente per inserire il comportamento nel ciclo di vita. request/response In questo modo, puoi modificare una richiesta in corso, eseguire il debug dell'elaborazione delle richieste, visualizzare gli errori e altro ancora. 

L'esempio seguente mostra un semplice intercettore che aggiunge un'intestazione aggiuntiva a tutte le richieste in uscita prima che venga inserito il ciclo di ripetizione:

```
use std::borrow::Cow;
use aws_smithy_runtime_api::client::interceptors::{
    Intercept,
    context::BeforeTransmitInterceptorContextMut,   
};
use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
use aws_smithy_types::config_bag::ConfigBag;
use aws_smithy_runtime_api::box_error::BoxError;

#[derive(Debug)]
struct AddHeaderInterceptor {
    key: Cow<'static, str>,
    value: Cow<'static, str>,
}

impl AddHeaderInterceptor {
    fn new(key: &'static str, value: &'static str) -> Self {
        Self {
            key: Cow::Borrowed(key),
            value: Cow::Borrowed(value),
        }
    }
}

impl Intercept for AddHeaderInterceptor {
    fn name(&self) -> &'static str {
        "AddHeader"
    }

    fn modify_before_retry_loop(
        &self,
        context: &mut BeforeTransmitInterceptorContextMut<'_>,
        _runtime_components: &RuntimeComponents,
        _cfg: &mut ConfigBag,
    ) -> Result<(), BoxError> {
        let headers = context.request_mut().headers_mut();
        headers.insert(self.key.clone(), self.value.clone());

        Ok(())
    }
}
```

[Per ulteriori informazioni e per conoscere gli hook di intercettazione disponibili, vedete il tratto Intercept.](https://docs.rs/aws-smithy-runtime-api/latest/aws_smithy_runtime_api/client/interceptors/trait.Intercept.html)

## Registrazione Interceptor
<a name="interceptors-registration"></a>

Gli intercettori vengono registrati quando si crea un client di servizio o quando si sostituisce la configurazione per un'operazione specifica. La registrazione è diversa a seconda che si desideri che l'interceptor si applichi a tutte le operazioni per il cliente o solo a quelle specifiche.

### Interceptor per tutte le operazioni su un client di servizio
<a name="interceptors-registration-all"></a>

Per registrare un intercettore per l'intero client, aggiungete l'intercettore utilizzando il pattern. `Builder`

```
let config = aws_config::defaults(BehaviorVersion::latest())
    .load()
    .await;
    
// All service operations invoked using 's3' will have the header added.
let s3_conf = aws_sdk_s3::config::Builder::from(&config)
    .interceptor(AddHeaderInterceptor::new("x-foo-version", "2.7"))
    .build();

let s3 = aws_sdk_s3::Client::from_conf(s3_conf);
```

### Interceptor solo per un'operazione specifica
<a name="interceptors-registration-specific"></a>

Per registrare un intercettore per una sola operazione, utilizzate l'estensione. `customize` È possibile sovrascrivere le configurazioni dei client di servizio a livello di singola operazione utilizzando questo metodo. Per ulteriori informazioni sulle operazioni personalizzabili, vedere. [Sovrascrivere una configurazione a singola operazione di un client nell' AWS SDK per Rust](peroperation.md)

```
// Only the list_buckets operation will have the header added.
s3.list_buckets()
    .customize()
    .interceptor(AddHeaderInterceptor::new("x-bar-version", "3.7"))
    .send()
    .await?;
```