Struct DefaultBodyLimit

struct DefaultBodyLimit { ... }

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::poll_frame, 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.

Example

use axum::{
    Router,
    routing::post,
    body::Body,
    extract::{Request, DefaultBodyLimit},
};

let app = Router::new()
    .route("/", post(|request: Request| async {}))
    // change the default limit
    .layer(DefaultBodyLimit::max(1024));
# let _: Router = app;

In general using DefaultBodyLimit is recommended but if you need to use third party extractors and want to make sure a limit is also applied there then RequestBodyLimit should be used.

Different limits for different routes

DefaultBodyLimit can also be selectively applied to have different limits for different routes:

use axum::{
    Router,
    routing::post,
    body::Body,
    extract::{Request, DefaultBodyLimit},
};

let app = Router::new()
    // this route has a different limit
    .route("/", post(|request: Request| async {}).layer(DefaultBodyLimit::max(1024)))
    // this route still has the default limit
    .route("/foo", post(|request: Request| async {}));
# let _: Router = app;

Implementations

impl DefaultBodyLimit

const 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;

let app: Router<()> = Router::new()
    .route("/", get(|body: Bytes| async {}))
    // Disable the default limit
    .layer(DefaultBodyLimit::disable())
    // Set a different limit
    .layer(RequestBodyLimitLayer::new(10 * 1000 * 1000));

const 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,
};

let app: Router<()> = Router::new()
    .route("/", get(|body: Bytes| async {}))
    // Replace the default of 2MB with 1024 bytes.
    .layer(DefaultBodyLimit::max(1024));

impl Clone for DefaultBodyLimit

fn clone(self: &Self) -> DefaultBodyLimit

impl Copy for DefaultBodyLimit

impl Debug for DefaultBodyLimit

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl Freeze for DefaultBodyLimit

impl RefUnwindSafe for DefaultBodyLimit

impl Send for DefaultBodyLimit

impl Sync for DefaultBodyLimit

impl Unpin for DefaultBodyLimit

impl UnsafeUnpin for DefaultBodyLimit

impl UnwindSafe for DefaultBodyLimit

impl<S> Layer for DefaultBodyLimit

fn layer(self: &Self, inner: S) -> <Self as >::Service

impl<T> Any for DefaultBodyLimit

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for DefaultBodyLimit

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for DefaultBodyLimit

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for DefaultBodyLimit

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for DefaultBodyLimit

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> FromRef for DefaultBodyLimit

fn from_ref(input: &T) -> T

impl<T> Instrument for DefaultBodyLimit

impl<T> ToOwned for DefaultBodyLimit

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T> WithSubscriber for DefaultBodyLimit

impl<T, U> Into for DefaultBodyLimit

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for DefaultBodyLimit

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for DefaultBodyLimit

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>