Descripción general

El middleware Iris Body Limit es una poderosa herramienta para controlar el tamaño de los cuerpos de solicitud entrantes en sus aplicaciones web Iris. Al establecer un límite en el tamaño de los cuerpos de solicitud, puede evitar que los clientes envíen cargas útiles excesivamente grandes que podrían saturar su servidor o provocar ataques de denegación de servicio (DoS). Este middleware es particularmente útil para aplicaciones que manejan cargas de archivos, cargas JSON o cualquier otro tipo de datos cuyo tamaño pueda variar significativamente.

¿Por qué utilizar el middleware Body Limit?

Seguridad

Una de las razones principales para utilizar middleware de límite corporal es mejorar la seguridad de su aplicación. Al limitar el tamaño de los cuerpos de las solicitudes entrantes, puede mitigar el riesgo de ataques DoS, donde un atacante envía grandes cargas útiles para agotar los recursos del servidor.

Actuación

Limitar el tamaño de los cuerpos de solicitud también puede mejorar el rendimiento de su aplicación. Las cargas útiles grandes pueden consumir cantidades significativas de memoria y potencia de procesamiento, lo que ralentiza el servidor y afecta la experiencia del usuario. Al establecer un límite razonable, puede asegurarse de que su servidor siga respondiendo y siendo eficiente.

Gestión de recursos

En aplicaciones que manejan cargas de archivos o cargas útiles JSON de gran tamaño, es esencial administrar los recursos de manera efectiva. Al establecer un límite de cuerpo, puedes evitar que los clientes carguen archivos excesivamente grandes o envíen objetos JSON enormes que podrían sobrecargar los recursos de tu servidor.

Instalación

Para utilizar el middleware bodylimit, debe importarlo en su aplicación Iris:

import "github.com/kataras/iris/v12/middleware/bodylimit"

Uso

Configuración básica

Para utilizar el middleware de límite de cuerpo, debe crear una aplicación Iris y registrar el middleware. A continuación se muestra un ejemplo de cómo configurar el middleware con un límite de 2 MB:

package main

import (
    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/bodylimit"
)

func main() {
    app := iris.New()
    app.Use(bodylimit.New(2 * iris.MB)) // set the limit to 2 MB.

    handler := func(ctx iris.Context) {
        body, err := ctx.Body()
        if err != nil {
            ctx.StopWithPlainError(iris.StatusInternalServerError, err)
            return
        }

        ctx.Write(body) // write the request body back to the client.
    }

    app.Post("/", handler)
    app.Listen(":8080")
}

Explicación

• Límite: La función bodylimit.New toma un único parámetro, que es el tamaño máximo del cuerpo de la solicitud en bytes. En el ejemplo anterior, el límite se establece en 10 bytes.
• Manejador: el manejador lee el cuerpo de la solicitud y lo escribe en la respuesta. Si el cuerpo de la solicitud excede el límite, el middleware detendrá la solicitud y devolverá un estado 413 Request Entity Too Large.
• El middleware de límite de cuerpo utiliza un sync.Pool para administrar instancias de Reader, que se utilizan para leer el cuerpo de la solicitud y aplicar el límite de tamaño. Este enfoque garantiza un uso eficiente de la memoria y reduce la sobrecarga de crear nuevas instancias de Reader para cada solicitud.

Controladores de prueba con BodyLimit Middleware

Para probar los controladores que usan el middleware BodyLimit, puede usar el paquete httptest proporcionado por Iris. A continuación se muestra un ejemplo de cómo probar un controlador:

package main_test

import (
    "testing"

    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/httptest"
    "github.com/kataras/iris/v12/middleware/bodylimit"
)

func TestBodyLimit(t *testing.T) {
    limit := int64(10) // set the limit to 10 bytes for the shake of the test.

    handler := func(ctx iris.Context) {
        body, err := ctx.Body()
        if err != nil {
            ctx.StopWithPlainError(iris.StatusInternalServerError, err)
            return
        }
        ctx.Write(body)
    }

    app := iris.New()
    app.Use(bodylimit.New(limit))
    app.Post("/", handler)

    e := httptest.New(t, app)

    // Test with a body that is smaller than the limit.
    e.POST("/").WithText("123456789").Expect().Status(iris.StatusOK).Body().IsEqual("123456789")

    // Test with a body that is equal to the limit.
    e.POST("/").WithText("1234567890").Expect().Status(iris.StatusOK).Body().IsEqual("1234567890")

    // Test with a body that is bigger than the limit.
    e.POST("/").WithText("12345678910").Expect().Status(iris.StatusRequestEntityTooLarge)
}

Conclusión

El middleware Iris Body Limit proporciona una manera simple pero efectiva de controlar el tamaño de los cuerpos de solicitud entrantes en sus aplicaciones web Iris. Al establecer un límite en el tamaño de los cuerpos de solicitud, puede mejorar la seguridad, el rendimiento y la gestión de recursos de su aplicación. Con una fácil integración y funciones avanzadas, este middleware es una herramienta valiosa para cualquier desarrollador de Iris.