Iris Community Middleware List

Build status

This repository provides a way to share community-based middlewares for Iris v12.2.0+ (currently master branch). Among with those, you can also navigate through the builtin Iris handlers.


Install a middleware, take for example the jwt one.

$ go mod init myapp
$ go get[email protected]
$ go get

import as

import ""

// [...Code]


$ go build

Middleware is just a chain handlers which can be executed before or after the main handler, can transfer data between handlers and communicate with third-party libraries, they are just functions.

Middleware Description Example
jwt Middleware checks for a JWT on the Authorization header on incoming requests and decodes it jwt/_example
cors HTTP Access Control. cors/_example
secure Middleware that implements a few quick security wins secure/_example
tollbooth Generic middleware to rate-limit HTTP requests tollboothic/_examples/limit-handler
cloudwatch AWS cloudwatch metrics middleware cloudwatch/_example
newrelic/v3 Official New Relic Go Agent newrelic/_example
prometheus Easily create metrics endpoint for the prometheus instrumentation tool prometheus/_example
casbin An authorization library that supports access control models like ACL, RBAC, ABAC casbin/_examples
sentry-go (ex. raven) Sentry client in Go sentry-go/example/iris
csrf Cross-Site Request Forgery Protection csrf/_example
go-i18n Iris i18n Loader for nicksnyder/go-i18n go-i18n/_example
throttler Rate limiting access to HTTP endpoints throttler/_example

Register a middleware

To a single route

app := iris.New()

func onBegin(ctx iris.Context) { /* ... */ ctx.Next() }
func mySecondMiddleware(ctx iris.Context) { /* ... */ ctx.Next() }
func mainHandler(ctx iris.Context) { /* ... */ }

To a party of routes or subdomain

p := app.Party("/sellers", authMiddleware, logMiddleware)


p := app.Party("/customers")

To all routes

app.Use(func(ctx iris.Context) { }, myMiddleware2)

To global, all registered routes (including the http errors)

app.UseGlobal(func(ctx iris.Context) { }, myMiddleware2)

To Party and its children, even on unmatched routes and errors

app.UseRouter(func(ctx iris.Context) { }, myMiddleware2))

Can I use standard net/http handler with iris?

Yes you can, just pass the Handler inside the iris.FromStd in order to be converted into iris.Handler and register it as you saw before.

Convert handler which has the form of http.Handler/HandlerFunc

package main

import (

func main() {
    app := iris.New()

    sillyHTTPHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){

    sillyConvertedToIon := iris.FromStd(sillyHTTPHandler)
    // FromStd can take (http.ResponseWriter, *http.Request, next http.Handler) too!



If you are interested in contributing to this project, please push a PR.


List of all contributors


Community Middleware List for the Iris Web Framework.

Middleware Info

⭐ Stars 176
🔗 Homepage
🔗 Source Code
🕒 Last Update 9 months ago
🕒 Created 5 years ago
🐞 Open Issues 3
➗ Star-Issue Ratio 59
😎 Author iris-contrib