Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verarbeitung von HTTP-Ereignissen mit Rust
<a name="rust-http-events"></a>

Amazon API Gateway APIs, Application Load Balancers und [Lambda-Funktionen URLs können HTTP-Ereignisse an Lambda](urls-configuration.md) senden. Sie können den [aws\$1lambda\$1events](https://crates.io/crates/aws_lambda_events) Crate von crates.io verwenden, um Ereignisse aus diesen Quellen zu verarbeiten.

**Example – API Gateway Proxy-Anfrage bearbeiten**  
Beachten Sie Folgendes:  
+ `use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse}`: Der [aws\$1lambda\$1events](https://crates.io/crates/aws-lambda-events) Crate enthält viele Lambda-Ereignisse. Um die Kompilierungszeit zu verkürzen, verwenden Sie Feature-Flags, um die benötigten Ereignisse zu aktivieren. Beispiel: `aws_lambda_events = { version = "0.8.3", default-features = false, features = ["apigw"] }`.
+ `use http::HeaderMap`: Für diesen Import müssen Sie den [HTTP](https://crates.io/crates/http) Crate zu Ihren Abhängigkeiten hinzufügen.

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

Der [Rust-Laufzeit-Client für Lambda](https://github.com/aws/aws-lambda-rust-runtime) bietet auch eine Abstraktion dieser Ereignistypen, die es Ihnen ermöglicht, mit nativen HTTP-Typen zu arbeiten, unabhängig davon, welcher Service die Ereignisse sendet. Der folgende Code entspricht dem vorherigen Beispiel und funktioniert sofort mit Lambda-Funktion URLs, Application Load Balancers und API Gateway.

**Anmerkung**  
Der [lambda\$1http](https://crates.io/crates/lambda_http) Crate verwendet den darunter liegenden [lambda\$1runtime](https://crates.io/crates/lambda_runtime) Crate. Sie müssen `lambda_runtime` nicht separat importieren.

**Example – Bearbeitung von HTTP-Anforderungen**  

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

Ein weiteres Beispiel für die Verwendung `lambda_http` finden Sie im [Codebeispiel http-axum](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-axum/src/main.rs) im Labs-Repository. AWS GitHub 

**Beispiel für HTTP-Lambda-Ereignisse für Rust**
+ [Lambda-HTTP-Ereignisse](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/http-basic-lambda): Eine Rust-Funktion, die HTTP-Ereignisse verarbeitet.
+ [Lambda-HTTP-Ereignisse mit CORS-Headern](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-cors): Eine Rust-Funktion, die Tower verwendet, um CORS-Header zu injizieren.
+ [Lambda-HTTP-Ereignisse mit gemeinsam genutzten Ressourcen](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/basic-shared-resource): Eine Rust-Funktion, die gemeinsam genutzte Ressourcen verwendet, die initialisiert werden, bevor der Funktionshandler erstellt wird.