Advice on lambda_http integration

[tmpfs]

I have a service that I would like to work on AWS lambda via API Gateway and as a standalone server so I can choose between serverless and a managed server.

I have the API working well as a standalone server and I can get it working via API Gateway/Lambda with a crude proxy function. The main restrictions are that the API Gateway Proxy integration requires a single wildcard route and use of any() method.

So my code for the lambda deployment ends up looking something like this (abbreviated for brevity):

use anyhow::Result;
use axum::{
    body::Bytes,
    http::StatusCode,
    http::{Method, Request},
    routing::any,
    Router,
};
use lambda_http::{run, Error};

async fn proxy_handler(
    request: Request<lambda_http::Body>,
) -> RouteResult {
    let (parts, body) = request.into_parts();
    let path = parts.uri.path().to_owned();
    let headers = parts.headers;
    let method = parts.method;
    let body: Bytes = body.to_vec().into();

    let mut path_parts = path.split("/").collect::<Vec<_>>();

    tracing::info!(parts = ?path_parts, "proxy_handler");

    if path_parts.is_empty() {
        return Err(StatusCode::NOT_FOUND.into());
    }

    let _stage = path_parts.remove(0);
    if path_parts.is_empty() {
        return Err(StatusCode::NOT_FOUND.into());
    }

    let key = path_parts.join("/");

    tracing::info!(key = ?key, "proxy_handler");

    // Code to match on method and path
    // and call the appropriate route handlers with header and body etc
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    let app = Router::new()
        .route("/*path", any(proxy_handler));
    run(app).await
}

So whilst this works it is horrible. Is there a better way to achieve this whereby I could:

1. Strip the path prefix from API Gateway
2. Proxy the modified request to my standard server router/service

Any suggestions welcome, thanks 🙏

[davidpdrsn]

The main restrictions are that the API Gateway Proxy integration requires a single wildcard route and use of any() method.

Why? What enforces this restriction? The code you wrote seems like it could just use a routing.

[tmpfs]

Maybe this will help clarify, when I invoke the lambda with this payload:

{
  "body": "",
  "resource": "/",
  "path": "/",
  "httpMethod": "GET",
  "isBase64Encoded": false,
  "queryStringParameters": {},
  "multiValueQueryStringParameters": {},
  "pathParameters": {},
  "stageVariables": {},
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
    "Accept-Encoding": "gzip, deflate, sdch",
    "Accept-Language": "en-US,en;q=0.8",
    "Cache-Control": "max-age=0",
    "CloudFront-Forwarded-Proto": "https",
    "CloudFront-Is-Desktop-Viewer": "true",
    "CloudFront-Is-Mobile-Viewer": "false",
    "CloudFront-Is-SmartTV-Viewer": "false",
    "CloudFront-Is-Tablet-Viewer": "false",
    "CloudFront-Viewer-Country": "US",
    "Host": "1234567890.execute-api.us-east-1.amazonaws.com",
    "Upgrade-Insecure-Requests": "1",
    "User-Agent": "Custom User Agent String",
    "Via": "1.1 08f323deadbeefa7af34d5feb414ce27.cloudfront.net (CloudFront)",
    "X-Amz-Cf-Id": "cDehVQoZnx43VYQb9j2-nvCh-9z396Uhbp027Y2JvkCPNLmGJHqlaA==",
    "X-Forwarded-For": "127.0.0.1, 127.0.0.2",
    "X-Forwarded-Port": "443",
    "X-Forwarded-Proto": "https"
  },
  "multiValueHeaders": {
    "Accept": [
      "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
    ],
    "Accept-Encoding": [
      "gzip, deflate, sdch"
    ],
    "Accept-Language": [
      "en-US,en;q=0.8"
    ],
    "Cache-Control": [
      "max-age=0"
    ],
    "CloudFront-Forwarded-Proto": [
      "https"
    ],
    "CloudFront-Is-Desktop-Viewer": [
      "true"
    ],
    "CloudFront-Is-Mobile-Viewer": [
      "false"
    ],
    "CloudFront-Is-SmartTV-Viewer": [
      "false"
    ],
    "CloudFront-Is-Tablet-Viewer": [
      "false"
    ],
    "CloudFront-Viewer-Country": [
      "US"
    ],
    "Host": [
      "0123456789.execute-api.us-east-1.amazonaws.com"
    ],
    "Upgrade-Insecure-Requests": [
      "1"
    ],
    "User-Agent": [
      "Custom User Agent String"
    ],
    "Via": [
      "1.1 08f323deadbeefa7af34d5feb414ce27.cloudfront.net (CloudFront)"
    ],
    "X-Amz-Cf-Id": [
      "cDehVQoZnx43VYQb9j2-nvCh-9z396Uhbp027Y2JvkCPNLmGJHqlaA=="
    ],
    "X-Forwarded-For": [
      "127.0.0.1, 127.0.0.2"
    ],
    "X-Forwarded-Port": [
      "443"
    ],
    "X-Forwarded-Proto": [
      "https"
    ]
  },
  "requestContext": {
    "accountId": "123456789012",
    "resourceId": "123456",
    "stage": "prod",
    "requestId": "c6af9ac6-7b61-11e6-9a41-93e8deadbeef",
    "requestTime": "09/Apr/2015:12:34:56 +0000",
    "requestTimeEpoch": 1428582896000,
    "identity": {
      "cognitoIdentityPoolId": null,
      "accountId": null,
      "cognitoIdentityId": null,
      "caller": null,
      "accessKey": null,
      "sourceIp": "127.0.0.1",
      "cognitoAuthenticationType": null,
      "cognitoAuthenticationProvider": null,
      "userArn": null,
      "userAgent": "Custom User Agent String",
      "user": null
    },
    "path": "/",
    "resourcePath": "/",
    "httpMethod": "GET",
    "apiId": "1234567890",
    "protocol": "HTTP/1.1"
  }
}

The request URI is: https://1234567890.execute-api.us-east-1.amazonaws.com/prod/ so I need to strip the "prod" from the beginning of the path before routing.

[davidpdrsn]

You can use https://docs.rs/axum/latest/axum/routing/struct.Router.html#method.nest or https://docs.rs/axum/latest/axum/routing/struct.Router.html#method.nest_service

[tmpfs]

Thanks @davidpdrsn, that really helped. My problem was that I was trying to strip the prefix rather than embracing it. So now I name the API Gateway stages for versioning (eg: v1) and then use nest_service() so I don't have to prefix all the routes.

    let cors = server::cors()?;
    let v1 = Router::new()
    // Lots of routes removed
    .layer(cors);

    let app = Router::new()
        .nest_service(&format!("/{}", V1), v1)
        .layer(cors);

The only remaining problem is that I have to duplicate the route definitions between the standalone server and the lambda implementation as I haven't been able to figure out a function signature for returning a Router that works for both axum::body::Body and lambda_http::Body (which is required to call lambda_http::run()).

Thanks for your help 🙏

[jplatte]

Side note: in your snippet, two cors layers are applied to every request in /v1. That seems like a bad idea.

[tmpfs]

Good catch, thanks @jplatte!

[tmpfs]

Having researched this some more I think the only way to do this is to strip a prefix from the request URI before routing begins.

This is what I want to achieve:

• Apply a version prefix to all my routes (eg: v1)
• Run all routes as a standalone server for local development and integration testing
• Support routing to an AWS lambda function via API Gateway (proxy resource with lambda proxy integration)

Please bear in mind this entire problem is because API Gateway made the dubious decision to include the stage as a path prefix.

I got the version prefix working thanks to the tip from @davidpdrsn on using nest_service() however we have to strip the stage prefix because when calling API Gateway and using a custom domain name we don't specify the prefix in the URI but the backend lambda is invoked with it.

In API Gateway create a base path mapping for the custom domain name, let's call the stage (dev) and the base path v1.

We would invoke this with:

curl -L api.example.com/v1/

Which when the API Gateway transforms it and invokes the lambda it will be exposed to axum as:

/dev/v1/

So I created middleware which rewrites the request URI but this doesn't work when I invoke via lambda (thanks to cargo lambda I can test this locally) because I think that axum is already doing the routing based on the initial request URI. All I get are 404 responses after applying the middleware.

Is there a mechanism in the Router to allow stripping a prefix from the request path before routing? If not could we add one please?

[tmpfs]

My bad, I can get it to work with two nest_service() calls.

First, route the v1 prefix:

/// Get the service.
pub fn service() -> anyhow::Result<Router<(), lambda_http::Body>> {
    let cors = server::cors()?;
    let v1 = Router::new(); // all the routes go here!

    let app = Router::new()
        .nest_service(&format!("/{}", V1), v1)
        .layer(cors);

    Ok(app)
}

Then in the lambda an additional /:stage with nest_service() works:

#[tokio::main]
async fn main() -> anyhow::Result<(), Error> {
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .with_target(false)
        .without_time()
        .init();

    let app = Router::new()
        .nest_service("/:stage", service()?);
    run(app).await // from lambda_http
}

[tmpfs]

Now the final part of the puzzle is sharing the Router between the server (axum::body::Body) and lambda (lambda_http::Body), but I am struggling with the limits of my understanding of the Rust type system.

I have this function definition:

    pub fn service<B>() -> Router<(), B> where
        B: HttpBody + Send + 'static,
        <B as HttpBody>::Data: Send,
        <B as HttpBody>::Error: Send + Sync + std::error::Error + 'static
    {
    Router::new() // all the service routes
    }

Which works fine for the normal axum server. However, when I try to invoke the function from the lambda I get this error:

   |
66 |     let v1 = server::Server::service();
   |              ^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `Sized` is not implemented for `(dyn std::error::Error + Send + Sync + 'static)`
   = help: the following other types implement trait `std::error::Error`:
             Box<(dyn sqlx_core::error::DatabaseError + 'static)>
             Box<T>
   = note: required for `Box<(dyn std::error::Error + Send + Sync + 'static)>` to implement `std::error::Error`
note: required by a bound in `sos_platform::server::Server::service`
  --> /Users/muji/git/sos/platform/src/server.rs:76:47
   |
76 |         <B as HttpBody>::Error: Send + Sync + std::error::Error + 'static
   |                                               ^^^^^^^^^^^^^^^^^ required by this bound in `Server::service`

For more information about this error, try `rustc --explain E0277`.

I can't remove the std::error::Error trait bound as it is required by axum routing:

error[E0277]: the trait bound `<B as HttpBody>::Error: StdError` is not satisfied
   --> src/server.rs:82:36
    |
82  |             .route("/signup", post(signup::intent))
    |                               ---- ^^^^^^^^^^^^^^ the trait `StdError` is not implemented for `<B as HttpBody>::Error`
    |                               |
    |                               required by a bound introduced by this call

Any ideas how to fix this? Thanks 🙏

[tmpfs]

The type definition that appears to be causing this is here: https://github.com/tmpfs/aws-lambda-rust-runtime/blob/main/lambda-events/src/encodings/mod.rs#L15

[tmpfs]

I asked on the lambda runtime repository: awslabs/aws-lambda-rust-runtime#685

Sure would be nice not to have to duplicate those routes!

I want to thank both @davidpdrsn and all the axum contributors for your amazing work and for being so helpful, having used both actix and warp in the past axum is a very refreshing design and is my go to web framework for Rust! Thank you 🙏