add axum streaming example

Author: s0l0ist

examples/http-axum-streaming/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "http-axum-streaming"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+axum = "0.8"
+bytes = "1"
+futures-util = "0.3"
+lambda_http = { path = "../../lambda-http", default-features = false, features = [
+  "apigw_rest", "apigw_http", "tracing"
+] }
+thiserror = "2.0"
+tokio = { version = "1", features = ["macros"] }
+tokio-stream = "0.1.2"

examples/http-axum-streaming/README.md

@@ -0,0 +1,15 @@
+# AWS Lambda Function example
+
+This example demonstrates building a **streaming** HTTP response with Axum, deployed on AWS Lambda using a custom runtime.
+
+## Build & Deploy
+
+1. Install [cargo-lambda](https://github.com/cargo-lambda/cargo-lambda#installation)
+2. Build the function with `cargo lambda build --release`
+3. Deploy the function to AWS Lambda with `cargo lambda deploy --enable-function-url --iam-role YOUR_ROLE`
+4. Enable Lambda streaming response on Lambda console: change the function url's invoke mode to `RESPONSE_STREAM`
+5. Verify the function works: `curl -v -N <function-url>`. The results should be streamed back with 0.5 second pause between each word.
+
+## Build for ARM 64
+
+Build the function with `cargo lambda build --release --arm64`

examples/http-axum-streaming/src/main.rs

@@ -0,0 +1,62 @@
+use axum::{
+    body::Body,
+    http,
+    http::{
+        header::{CACHE_CONTROL, CONTENT_TYPE},
+        StatusCode,
+    },
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use bytes::Bytes;
+use lambda_http::{lambda_runtime, tracing, Error, StreamAdapter};
+use std::{convert::Infallible, time::Duration};
+use thiserror::Error;
+use tokio::sync::mpsc;
+use tokio_stream::wrappers::ReceiverStream;
+
+#[derive(Debug, Error)]
+pub enum AppError {
+    #[error("{0}")]
+    Http(#[from] http::Error),
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string()).into_response()
+    }
+}
+
+type AppResult<T = Response> = Result<T, AppError>;
+
+async fn stream_handler() -> AppResult {
+    let (tx, rx) = mpsc::channel::<Result<Bytes, Infallible>>(8);
+    let body = Body::from_stream(ReceiverStream::new(rx));
+
+    tokio::spawn(async move {
+        for msg in ["Hello", "world", "from", "Lambda!"] {
+            tokio::time::sleep(Duration::from_millis(500)).await;
+            if tx.send(Ok(Bytes::from(format!("{msg}\n")))).await.is_err() {
+                break;
+            }
+        }
+    });
+
+    Ok(Response::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, "text/plain; charset=utf-8")
+        .header(CACHE_CONTROL, "no-cache")
+        .body(body)?)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    tracing::init_default_subscriber();
+
+    let app = Router::new().route("/", get(stream_handler));
+
+    let runtime = lambda_runtime::Runtime::new(StreamAdapter::from(app));
+
+    runtime.run().await
+}