Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Traitement des événements HTTP avec Rust
<a name="rust-http-events"></a>

Amazon API Gateway APIs, les équilibreurs de charge d'application et la URLs fonction [Lambda](urls-configuration.md) peuvent envoyer des événements HTTP à Lambda. Vous pouvez utiliser la caisse [aws\$1lambda\$1events](https://crates.io/crates/aws_lambda_events) de crates.io pour traiter les événements provenant de ces sources.

**Example – Gestion de la demande de proxy API Gateway**  
Notez ce qui suit :  
+ `use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse}` : la caisse [aws\$1lambda\$1events](https://crates.io/crates/aws-lambda-events) inclut de nombreux événements Lambda. Pour réduire le temps de compilation, utilisez les drapeaux de fonction pour activer les événements dont vous avez besoin. Exemple: `aws_lambda_events = { version = "0.8.3", default-features = false, features = ["apigw"] }`.
+ `use http::HeaderMap` : cette importation nécessite d’ajouter la caisse [http](https://crates.io/crates/http) à vos dépendances.

```
use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse};
use http::HeaderMap;
use lambda_runtime::{service_fn, Error, LambdaEvent};

async fn handler(
    _event: LambdaEvent<ApiGatewayProxyRequest>,
) -> Result<ApiGatewayProxyResponse, Error> {
    let mut headers = HeaderMap::new();
    headers.insert("content-type", "text/html".parse().unwrap());
    let resp = ApiGatewayProxyResponse {
        status_code: 200,
        multi_value_headers: headers.clone(),
        is_base64_encoded: false,
        body: Some("Hello AWS Lambda HTTP request".into()),
        headers,
    };
    Ok(resp)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_runtime::run(service_fn(handler)).await
}
```

Le [client d’exécution Rust pour Lambda](https://github.com/aws/aws-lambda-rust-runtime) fournit également une abstraction sur ces types d’événements qui vous permet de travailler avec les types HTTP natifs, quel que soit le service qui envoie les événements. Le code suivant est équivalent à l'exemple précédent et fonctionne immédiatement avec la fonction Lambda URLs, les équilibreurs de charge d'application et l'API Gateway.

**Note**  
À la base, la caisse [lambda\$1http](https://crates.io/crates/lambda_http) utilise la caisse [lambda\$1runtime](https://crates.io/crates/lambda_runtime). Vous n’avez pas besoin d’importer `lambda_runtime` séparément.

**Example – Gestion des requêtes HTTP**  

```
use lambda_http::{service_fn, Error, IntoResponse, Request, RequestExt, Response};

async fn handler(event: Request) -> Result<impl IntoResponse, Error> {
    let resp = Response::builder()
        .status(200)
        .header("content-type", "text/html")
        .body("Hello AWS Lambda HTTP request")
        .map_err(Box::new)?;
    Ok(resp)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_http::run(service_fn(handler)).await
}
```

Pour un autre exemple d'utilisation`lambda_http`, consultez l'exemple de [code http-axum sur le AWS référentiel](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-axum/src/main.rs) Labs. GitHub 

**Exemples d’événements HTTP Lambda pour Rust**
+ [Événements HTTP Lambda](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/http-basic-lambda) : une fonction Rust qui gère les événements HTTP.
+ [Événements HTTP Lambda avec en-têtes CORS](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-cors) : une fonction Rust qui utilise Tower pour injecter des en-têtes CORS.
+ [Événements HTTP Lambda avec ressources partagées](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/basic-shared-resource) : une fonction Rust qui utilise des ressources partagées initialisées avant la création du gestionnaire de fonction.