Iris Community Middleware List

This repository provides a way to share community-based middlewares for Iris Web Framework. Among with those, you can also navigate through the builtin Iris handlers.

Installation

Install a middleware, take for example the jwt one.

$ go env -w GOPROXY=goproxy.cn,gocenter.io,goproxy.io,direct
$ go mod init myapp
$ go get github.com/kataras/iris/v12@main
$ go get github.com/iris-contrib/middleware/jwt@master

import as

import "github.com/iris-contrib/middleware/jwt"

// [...Code]

build

$ 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
pg	PostgreSQL Database	pg/_examples
jwt	JSON Web Tokens	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
throttler	Rate limiting access to HTTP endpoints	throttler/_example
expmetric	Expvar for counting requests etc.	expmetric/_example
zap	Provides log handling using zap package	zap/_examples

Register a middleware

To a single route

app := iris.New()
app.Get("/mypath",
  onBegin,
  mySecondMiddleware,
  mainHandler,
)

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)

OR

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

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 (
    "github.com/kataras/iris/v12"
)

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

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

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

    app.Listen(":8080")
}

Contributing

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

People

List of all contributors