description: >- Middleware is a function chained in the HTTP request cycle with access to the Context which it uses to perform a specific action, for example, logging every

request or enabling CORS.

🧬 Middleware

Basic Auth

Basic auth middleware provides an HTTP basic authentication. It calls the next handler for valid credentials and 401 Unauthorized for missing or invalid credentials.

Installation

go get -u github.com/gofiber/basicauth

Signature

basicauth.New(config ...Config) func(*fiber.Ctx)

Config

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/basicauth"
)
func main() {
  app := fiber.New()
  cfg := basicauth.Config{
    Users: map[string]string{
      "john":   "doe",
      "admin":  "123456",
    },
  }
  app.Use(basicauth.New(cfg))
  app.Get("/", func(c *fiber.Ctx) {
    c.Send("Welcome!")
  })
  log.Fatal(app.Listen(":3000"))
}

CORS

CORS middleware implements CORS specification. CORS gives web servers cross-domain access controls, which enable secure cross-domain data transfers.

Installation

go get -u github.com/gofiber/cors

Signature

cors.New(config ...Config) func(*fiber.Ctx)

Config

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/cors"
)
func main() {
  app := fiber.New()
  app.Use(cors.New())
  app.Get("/", func(c *fiber.Ctx) {
    c.Send("Welcome!")
  })
  log.Fatal(app.Listen(":3000"))
  // curl -H "Origin: http://example.com" --verbose http://localhost:3000
}

Compression

This middleware allows dynamic compression for gzip & deflate if you your responses are bigger than 4kb. If you want to enable compression for static files only, please use the Compression setting inside the Static method.

Installation

go get -u github.com/gofiber/compression

Signature

compression.New(config ...Config) func(*fiber.Ctx)

Config

package main
import
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/compression"
)
func main() {
  app := fiber.New()
  app.Use(compression.New())
  app.Get("/", func(c *fiber.Ctx) {
    c.Send("Welcome!")
  })
  log.Fatal(app.Listen(":3000"))
}

Limiter

Use to limit repeated requests to public APIs and/or endpoints such as password reset. This middleware does not share state with other processes/servers.

Installation

go get -u github.com/gofiber/limiter

Signature

limiter.New(config ...Config) func(*Ctx)

Config

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/limiter"
)
func main() {
  app := fiber.New()
  // 3 requests per 10 seconds max
  cfg := limiter.Config{
    Timeout: 10,
    Max: 3,
  }
  app.Use(limiter.New(cfg))
  app.Get("/", func(c *fiber.Ctx) {
    c.Send("Welcome!")
  })
  log.Fatal(app.Listen(":3000"))
}

Logger

Logger middleware logs the information about each HTTP request.

Installation

go get -u github.com/gofiber/logger

Signature

logger.new(config ...Config) func(*Ctx)

Config

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/logger"
)
func main() {
  app := fiber.New()
  app.Use(logger.New())
  app.Get("/", func(c *fiber.Ctx) {
    c.Send("Welcome!")
  })
  log.Fatal(app.Listen(":3000"))
}

Recover

You can recover from panic errors within any route. By default the Recover middleware will respond with 500 Internal Server Error when a panic occurs. You can also provide your own error handler.

Installation

go get -u github.com/gofiber/recover

Signature

recover.New(config ...Config) func(*Ctx)

Example

package main
import (
    "log"
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/recover"
)
func main() {
    app := fiber.New()
    // Optional
    cfg := recover.Config{
        Handler: func(c *fiber.Ctx, err error) {
            c.SendString(err.Error())
            c.SendStatus(500)
        },
    }
    app.Use(recover.New(cfg))
    app.Get("/", func(c *fiber.Ctx) {
        panic("Hi, I'm a error!")
    })
    log.Fatal(app.Listen(":3000"))
}

Template

By default Fiber comes with the default HTML template engine, but this middleware contains third party rendering engines.

Installation

go get -u github.com/gofiber/template

Signature

template.Engine() func(raw string, bind interface{}) (out string, err error)

Template Engines

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/template"
)
func main() {
  app := fiber.New()
  app.Settings.TemplateEngine = template.Mustache()
  // app.Settings.TemplateEngine = template.Amber()
  // app.Settings.TemplateEngine = template.Handlebars()
  // app.Settings.TemplateEngine = template.Pug()
  app.Get("/", func(c *fiber.Ctx) {
    bind := fiber.Map{
      "name": "John",
      "age":  35,
    }
    if err := c.Render("./views/index.mustache", bind); err != nil {
      c.Status(500).Send(err.Error())
    }
    // <html><head><title>Template Demo</title></head>
    // <body>Hi, my name is John and im 35 years old
    // </body></html>
  })
  log.Fatal(app.Listen(":3000"))
}

WebSocket

Fiber supports a websocket upgrade middleware. The *Conn struct has all the functionality from the gorilla/websocket library.

Installation

go get -u github.com/gofiber/websocket

Signature

websocket.New(handler func(*Conn), config ...Config) func(*Ctx)

Config

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/websocket"
)
func main() {
  app := fiber.New()
  app.Use(func(c *fiber.Ctx) {
    c.Locals("Hello", "World")
    c.Next()
  })
  app.Get("/ws", websocket.New(func(c *websocket.Conn) {
    fmt.Println(c.Locals("Hello")) // "World"
    // Websocket logic...
    for {
      mt, msg, err := c.ReadMessage()
      if err != nil {
        log.Println("read:", err)
        break
      }
      log.Printf("recv: %s", msg)
      err = c.WriteMessage(mt, msg)
      if err != nil {
        log.Println("write:", err)
        break
      }
    }
  }))
  log.Fatal(app.Listen(":3000")) // ws://localhost:3000/ws
}

Request ID

Request ID adds an identifier to the request using the X-Request-ID header

Installation

go get -u github.com/gofiber/requestid

Signature

requestid.New(config ...Config) func(*Ctx)

Config

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/requestid"
)
func main() {
  app := fiber.New()
  app.Use(requestid.New())
  app.Get("/", func(c *fiber.Ctx) {
    c.Send(requestid.Get(c))
  })
  log.Fatal(app.Listen(":3000"))
}

Helmet

Helmet middleware provides protection against cross-site scripting (XSS) attack, content type sniffing, clickjacking, insecure connection and other code injection attacks.

Installation

go get -u github.com/gofiber/helmet

Signature

helmet.New(config ...Config) func(*Ctx)

Config

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/helmet"
)
func main() {
  app := fiber.New()
  app.Use(helmet.New())
  app.Get("/", func(c *fiber.Ctx) {
    c.Send("Welcome!")
  })
  log.Fatal(app.Listen(":3000"))
  // curl -I http://localhost:3000
}

Redirect

Redirects middleware provides an HTTP redirect to the URL derived from the specified path, with specified status, a positive integer that corresponds to an HTTP status code.

Installation

go get -u github.com/gofiber/redirect

Signature

redirect.New(config ...Config) func(*Ctx)

Example

package main
import (
  "log"
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/redirect"
)
func main() {
  app := fiber.New()
  app.Use(redirect.New(redirect.Config{
    Rules: map[string]string{
      "/old":   "/new",
      "/old/*": "/new/$1",
    },
    StatusCode: 301,
  }))
  app.Get("/new", func(c *fiber.Ctx) {
    c.Send("Hello, World!")
  })
  app.Get("/new/*", func(c *fiber.Ctx) {
    c.Send("Wildcard: ", c.Params("*"))
  })
  log.Fatal(app.Listen(":3000"))
}