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 apply the limit with
RequestExt::with_limited_body or RequestExt::into_limited_body
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 app = 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 app = 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§
source§impl 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§
source§impl Clone for DefaultBodyLimit
impl Clone for DefaultBodyLimit
source§fn clone(&self) -> DefaultBodyLimit
fn clone(&self) -> DefaultBodyLimit
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read moresource§impl Debug for DefaultBodyLimit
impl Debug for DefaultBodyLimit
Auto Trait Implementations§
impl Freeze for DefaultBodyLimit
impl RefUnwindSafe for DefaultBodyLimit
impl Send for DefaultBodyLimit
impl Sync for DefaultBodyLimit
impl Unpin for DefaultBodyLimit
impl UnwindSafe for DefaultBodyLimit
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit)