# Processamento de eventos de HTTP com o Rust
<a name="rust-http-events"></a>

As APIs do Amazon API Gateway, os Application Load Balancers e os [URLS de função do Lambda](urls-configuration.md) podem enviar eventos HTTP para o Lambda. É possível usar a caixa [aws\$1lambda\$1events](https://crates.io/crates/aws_lambda_events) do crates.io para processar eventos dessas origens.

**Example — Gerencia a solicitação de proxy da API Gateway**  
Observe o seguinte:  
+ `use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse}`: a caixa [aws\$1lambda\$1events](https://crates.io/crates/aws-lambda-events) inclui muitos eventos do Lambda. Para reduzir o tempo de compilação, use sinalizadores de recursos para ativar os eventos de que você precisa. Exemplo: `aws_lambda_events = { version = "0.8.3", default-features = false, features = ["apigw"] }`.
+ `use http::HeaderMap`: essa importação exige que você adicione a caixa [http](https://crates.io/crates/http) às suas dependências.

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

O [cliente de runtime Rust para Lambda](https://github.com/aws/aws-lambda-rust-runtime) também fornece uma abstração sobre esses tipos de eventos que permite trabalhar com tipos de HTTP nativos, independentemente de qual serviço envia os eventos. O código a seguir é equivalente ao exemplo anterior e funciona imediatamente com URLs de funções do Lambda, Application Load Balancers e API Gateway.

**nota**  
A caixa [lambda\$1http](https://crates.io/crates/lambda_http) usa a caixa [lambda\$1runtime](https://crates.io/crates/lambda_runtime) logo abaixo. Não é necessário importar `lambda_runtime` separadamente.

**Example — Trata solicitações de 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 ver outro exemplo de como usar `lambda_http`, consulte o [exemplo de código http-axum](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-axum/src/main.rs) no repositório do GitHub do AWS Labs.

**Exemplos de eventos de HTTP Lambda para Rust**
+ [Eventos de HTTP do Lambda](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/http-basic-lambda): uma função do Rust que manipula eventos HTTP.
+ [Eventos de HTTP do Lambda com cabeçalhos CORS](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-cors): uma função do Rust que usa o Tower para injetar cabeçalhos CORS.
+ [Eventos de HTTP do Lambda com recursos compartilhados](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/basic-shared-resource): uma função do Rust que usa recursos compartilhados inicializados antes do manipulador da função ser criado.