# Procesamiento de eventos HTTP con Rust
<a name="rust-http-events"></a>

Las API de Amazon API Gateway, los equilibradores de carga de aplicación y las [URL de la función de Lambda](urls-configuration.md) pueden enviar eventos HTTP a Lambda. Puede utilizar la caja [aws\$1lambda\$1events](https://crates.io/crates/aws_lambda_events) de crates.io para procesar eventos de estos orígenes.

**Example — Gestionar la solicitud de proxy de API Gateway**  
Tenga en cuenta lo siguiente:  
+ `use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse}`: la caja [aws\$1lambda\$1events](https://crates.io/crates/aws-lambda-events) incluye muchos eventos de Lambda. Para reducir el tiempo de compilación, utilice indicadores de funciones para activar los eventos que necesite. Ejemplo: : `aws_lambda_events = { version = "0.8.3", default-features = false, features = ["apigw"] }`.
+ `use http::HeaderMap`: esta importación requiere que agregue la caja [http](https://crates.io/crates/http) a sus dependencias.

```
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
}
```

El [cliente de tiempo de ejecución de Rust para Lambda](https://github.com/aws/aws-lambda-rust-runtime) también proporciona una abstracción sobre estos tipos de eventos que permite trabajar con tipos de HTTP nativos, independientemente del servicio que envíe los eventos. El siguiente código es equivalente al ejemplo anterior y funciona de forma inmediata con las URL de las funciones de Lambda, los equilibradores de carga de aplicación y API Gateway.

**nota**  
La caja [lambda\$1http](https://crates.io/crates/lambda_http) usa la caja [lambda\$1runtime](https://crates.io/crates/lambda_runtime) que se encuentra debajo. No es necesario que importe `lambda_runtime` por separado.

**Example — Gestionar solicitudes 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
}
```

Para obtener otro ejemplo sobre cómo usar `lambda_http`, consulte el [ejemplo de código http-axum](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-axum/src/main.rs) en el repositorio de GitHub de AWS Labs.

**Ejemplos de eventos HTTP Lambda para Rust**
+ [Eventos de Lambda HTTP](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/http-basic-lambda): una función de Rust que gestiona eventos HTTP.
+ [Eventos de Lambda HTTP con encabezados CORS](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-cors): una función de Rust que usa Tower para inyectar encabezados CORS.
+ [Eventos HTTP Lambda con recursos compartidos](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/basic-shared-resource): una función de Rust que usa recursos compartidos inicializados antes de crear el controlador de funciones.