Aperçu

Le middleware Iris Body Limit est un outil puissant pour contrôler la taille des corps de requêtes entrantes dans vos applications Web Iris. En définissant une limite sur la taille des corps de requête, vous pouvez empêcher les clients d'envoyer des charges utiles excessivement volumineuses qui pourraient potentiellement submerger votre serveur ou conduire à des attaques par déni de service (DoS). Ce middleware est particulièrement utile pour les applications qui gèrent les téléchargements de fichiers, les charges utiles JSON ou tout autre type de données dont la taille peut varier considérablement.

Pourquoi utiliser le middleware Body Limit ?

Sécurité

L'une des principales raisons d'utiliser un middleware de limite de corps est d'améliorer la sécurité de votre application. En limitant la taille des corps de requêtes entrantes, vous pouvez atténuer le risque d'attaques DoS, dans lesquelles un attaquant envoie des charges utiles volumineuses pour épuiser les ressources du serveur.

Performance

Limiter la taille des corps de requête peut également améliorer les performances de votre application. Les charges utiles volumineuses peuvent consommer des quantités importantes de mémoire et de puissance de traitement, ralentissant votre serveur et affectant l'expérience utilisateur. En fixant une limite raisonnable, vous pouvez vous assurer que votre serveur reste réactif et efficace.

Gestion des ressources

Dans les applications qui gèrent les téléchargements de fichiers ou les charges utiles JSON volumineuses, il est essentiel de gérer efficacement les ressources. En définissant une limite de corps, vous pouvez empêcher les clients de télécharger des fichiers excessivement volumineux ou d'envoyer d'énormes objets JSON qui pourraient mettre à rude épreuve les ressources de votre serveur.

Installation

Pour utiliser le middleware bodylimit, vous devez l'importer dans votre application Iris :

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

Usage

Configuration de base

Pour utiliser le middleware de limite de corps, vous devez créer une application Iris et enregistrer le middleware. Vous trouverez ci-dessous un exemple de configuration du middleware avec une limite de 2 Mo :

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

Explication

• Limit : la fonction bodylimit.New prend un seul paramètre, qui est la taille maximale du corps de la requête en octets. Dans l'exemple ci-dessus, la limite est fixée à 10 octets.
• Handler : le gestionnaire lit le corps de la requête et le réécrit dans la réponse. Si le corps de la requête dépasse la limite, le middleware arrêtera la requête et renverra un statut 413 Request Entity Too Large.
• Le middleware de limite de corps utilise un sync.Pool pour gérer les instances Reader, qui sont utilisées pour lire le corps de la requête et appliquer la limite de taille. Cette approche garantit une utilisation efficace de la mémoire et réduit la surcharge liée à la création de nouvelles instances Reader pour chaque requête.

Test des gestionnaires avec le middleware BodyLimit

Pour tester les gestionnaires qui utilisent le middleware BodyLimit, vous pouvez utiliser le package httptest fourni par Iris. Voici un exemple de comment tester un gestionnaire :

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

Conclusion

Le middleware Iris Body Limit fournit un moyen simple mais efficace de contrôler la taille des corps de requêtes entrantes dans vos applications Web Iris. En définissant une limite sur la taille des corps de requête, vous pouvez améliorer la sécurité, les performances et la gestion des ressources de votre application. Avec une intégration facile et des fonctionnalités avancées, ce middleware est un outil précieux pour tout développeur Iris.