How to send large BLOBs such as images without using multiport

[bokutotu]

Executing the following code will return 413. I am unable to send even a small file, even though I have the following configured in my middleware. is there any way to do this other than using multiport?

server

use axum::routing::{get, post};
use serde::{Deserialize, Serialize};

use tower_http::limit::RequestBodyLimitLayer;

#[derive(Serialize, Deserialize)]
struct User {
    name: String,
    age: u8,
    bytes: Vec<u8>,

}

#[derive(Serialize, Deserialize)]
struct Response {
    bytes: Vec<u8>,
}

async fn user_handler(axum::extract::Json(user): axum::extract::Json<User>) -> axum::response::Json<Response> {
    let bytes = user.bytes;
    axum::response::Json(Response { bytes })
}

#[tokio::main]
async fn main() {
    let app = axum::Router::new()
        .route("/", get(|| async { "Hello, World!" }))
        .route("/image", post(user_handler))
        .layer(RequestBodyLimitLayer::new(
            2014 * 1024 * 1024, /* 1GB */
        ));

    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

client

use reqwest::Client;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    name: String,
    age: u8,
    bytes: Vec<u8>,

}

#[derive(Serialize, Deserialize)]
struct Response {
    bytes: Vec<u8>,
}

#[tokio::main]
async fn main() {
    let client = Client::new();
    let image = image::open("../image/penguin.jpg").unwrap();
    let bytes = image.as_bytes();
    let user = User {
        name: "penguin".to_string(),
        age: 10,
        bytes: bytes.to_vec(),
    };
    let res = client.post("http://localhost:3000/image")
        .json(&user)
        .send()
        .await
        .unwrap();
    // assert!(res.status().is_success());
    println!("{:?}", res.status());
}

[davidpdrsn]

See the docs for DefaultBodyLimit. You need to disable the default limit as well, not only add a new limit.