Visão geral

O middleware Iris Body Limit é uma ferramenta poderosa para controlar o tamanho dos corpos de solicitação recebidos em seus aplicativos da web Iris. Ao definir um limite para o tamanho dos corpos de solicitação, você pode evitar que os clientes enviem cargas excessivamente grandes que poderiam sobrecarregar o servidor ou levar a ataques de negação de serviço (DoS). Este middleware é particularmente útil para aplicativos que lidam com uploads de arquivos, cargas JSON ou qualquer outro tipo de dados que possa variar significativamente em tamanho.

Por que usar o middleware Body Limit?

Segurança

Um dos principais motivos para usar o middleware body limit é aumentar a segurança do seu aplicativo. Ao limitar o tamanho dos corpos de solicitação recebidos, você pode mitigar o risco de ataques DoS, em que um invasor envia grandes cargas para esgotar os recursos do servidor.

Desempenho

Limitar o tamanho dos corpos de solicitação também pode melhorar o desempenho do seu aplicativo. Cargas grandes podem consumir quantidades significativas de memória e capacidade de processamento, tornando o servidor mais lento e afetando a experiência do usuário. Ao definir um limite razoável, você pode garantir que seu servidor permaneça responsivo e eficiente.

Gerenciamento de Recursos

Em aplicativos que lidam com uploads de arquivos ou grandes cargas JSON, é essencial gerenciar recursos de maneira eficaz. Ao definir um limite de corpo, você pode evitar que os clientes carreguem arquivos excessivamente grandes ou enviem objetos JSON enormes que podem sobrecarregar os recursos do seu servidor.

Instalação

Para usar o middleware bodylimit, você precisa importá-lo em seu aplicativo Iris:

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

Uso

Configuração básica

Para usar o middleware body limit, você precisa criar um aplicativo Iris e registrar o middleware. Abaixo segue um exemplo de como configurar o middleware com limite 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")
}

Explicação

• Limit: A função bodylimit.New usa um único parâmetro, que é o tamanho máximo do corpo da solicitação em bytes. No exemplo acima, o limite é definido como 10 bytes.
• Handler: O manipulador lê o corpo da solicitação e o grava de volta na resposta. Se o corpo da solicitação exceder o limite, o middleware interromperá a solicitação e retornará o status 413 Request Entity Too Large.
• O middleware body limit usa um sync.Pool para gerenciar instâncias do Reader, que são usadas para ler o corpo da solicitação e impor o limite de tamanho. Essa abordagem garante o uso eficiente da memória e reduz a sobrecarga de criação de novas instâncias do Reader para cada solicitação.

Testando manipuladores com BodyLimit Middleware

Para testar manipuladores que usam o middleware BodyLimit, você pode usar o pacote httptest fornecido pela Iris. Aqui está um exemplo de como testar um manipulador:

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)
}

Conclusão

O middleware Iris Body Limit fornece uma maneira simples, mas eficaz, de controlar o tamanho dos corpos de solicitação recebidos em seus aplicativos da web Iris. Ao definir um limite para o tamanho dos corpos de solicitação, você pode aprimorar a segurança, o desempenho e o gerenciamento de recursos do seu aplicativo. Com fácil integração e recursos avançados, este middleware é uma ferramenta valiosa para qualquer desenvolvedor Iris.