Struct axum_core::extract::DefaultBodyLimit
source · [−]pub struct DefaultBodyLimit { /* private fields */ }Expand description
Layer for configuring the default request body limit.
For security reasons, Bytes will, by default, not accept bodies larger than 2MB. This also
applies to extractors that uses Bytes internally such as String, Json, and Form.
This middleware provides ways to configure that.
Note that if an extractor consumes the body directly with Body::data, or similar, the
default limit is not applied.
Difference between DefaultBodyLimit and RequestBodyLimit
DefaultBodyLimit and RequestBodyLimit serve similar functions but in different ways.
DefaultBodyLimit is local in that it only applies to FromRequest implementations that
explicitly apply it (or call another extractor that does). You can currently only apply the
limit by delegating to one of axum’s FromRequest implementations, but this will change in
v0.6.0.
RequestBodyLimit is applied globally to all requests, regardless of which extractors are
used or how the body is consumed.
DefaultBodyLimit is also easier to integrate into an existing setup since it doesn’t change
the request body type:
use axum::{
Router,
routing::post,
body::Body,
extract::{DefaultBodyLimit, RawBody},
http::Request,
};
let router = Router::new()
.route(
"/",
// even with `DefaultBodyLimit` the request body is still just `Body`
post(|request: Request<Body>| async {}),
)
.layer(DefaultBodyLimit::max(1024));use axum::{Router, routing::post, body::Body, extract::RawBody, http::Request};
use tower_http::limit::RequestBodyLimitLayer;
use http_body::Limited;
let router = Router::new()
.route(
"/",
// `RequestBodyLimitLayer` changes the request body type to `Limited<Body>`
// extracting a different body type wont work
post(|request: Request<Limited<Body>>| async {}),
)
.layer(RequestBodyLimitLayer::new(1024));In general using DefaultBodyLimit is recommended but if you need to use third party
extractors and want to sure a limit is also applied there then RequestBodyLimit should be
used.
Implementations
sourceimpl DefaultBodyLimit
impl DefaultBodyLimit
sourcepub fn disable() -> Self
pub fn disable() -> Self
Disable the default request body limit.
This must be used to receive bodies larger than the default limit of 2MB using Bytes or
an extractor built on it such as String, Json, Form.
Note that if you’re accepting data from untrusted remotes it is recommend to add your own
limit such as tower_http::limit.
Example
use axum::{
Router,
routing::get,
body::{Bytes, Body},
extract::DefaultBodyLimit,
};
use tower_http::limit::RequestBodyLimitLayer;
use http_body::Limited;
let app: Router<Limited<Body>> = Router::new()
.route("/", get(|body: Bytes| async {}))
// Disable the default limit
.layer(DefaultBodyLimit::disable())
// Set a different limit
.layer(RequestBodyLimitLayer::new(10 * 1000 * 1000));sourcepub fn max(limit: usize) -> Self
pub fn max(limit: usize) -> Self
Set the default request body limit.
By default the limit of request body sizes that Bytes::from_request (and other
extractors built on top of it such as String, Json, and Form) is 2MB. This method
can be used to change that limit.
Example
use axum::{
Router,
routing::get,
body::{Bytes, Body},
extract::DefaultBodyLimit,
};
use tower_http::limit::RequestBodyLimitLayer;
use http_body::Limited;
let app: Router<Limited<Body>> = Router::new()
.route("/", get(|body: Bytes| async {}))
// Replace the default of 2MB with 1024 bytes.
.layer(DefaultBodyLimit::max(1024));Trait Implementations
sourceimpl Clone for DefaultBodyLimit
impl Clone for DefaultBodyLimit
sourcefn clone(&self) -> DefaultBodyLimit
fn clone(&self) -> DefaultBodyLimit
1.0.0 · sourceconst fn clone_from(&mut self, source: &Self)
const fn clone_from(&mut self, source: &Self)
source. Read more