Fiber

https://docs.gofiber.io/
Admin
Fiber is an Express-inspired web framework built on Fasthttp that provides high-performance HTTP...
Tokens:420,913
Snippets:4,770
Trust Score:8.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Local Development Setup (Manual)

Source: https://docs.gofiber.io/blog/spa-delivery-with-fiber-v3

Alternative local setup instructions for the React Router SPA example using manual toolchain installation and Go run.

```bash
cd web && yarn install && yarn build
cd ..
go run ./cmd/react-router/main.go
```

--------------------------------

### Installation and Setup

Source: https://docs.gofiber.io/storage/coherence

Commands to install the package and start a local Coherence cluster via Docker.

```bash
go get github.com/gofiber/storage/coherence
```

```bash
docker run -d -p 1408:1408 ghcr.io/oracle/coherence-ce:25.03
```

--------------------------------

### Start Fiber Server and Client

Source: https://docs.gofiber.io/contrib/otel/example

Use this command to bring up the necessary services for the example. Ensure docker-compose is installed.

```bash
docker-compose up --detach fiber-server fiber-client
```

--------------------------------

### Install Backend Dependencies

Source: https://docs.gofiber.io/recipes/spa

Navigate to the backend directory and install the Go dependencies using go get.

```bash
cd ../backend  

go get  
```

--------------------------------

### Basic Route Handler Examples

Source: https://docs.gofiber.io/api/app

Demonstrates simple GET and POST request handling using Fiber context.

```go
// Simple GET handler  

app.Get("/api/list", func(c fiber.Ctx) error {  

    return c.SendString("I'm a GET request!")  

})  

  

// Simple POST handler  

app.Post("/api/register", func(c fiber.Ctx) error {  

    return c.SendString("I'm a POST request!")  

})
```

--------------------------------

### Example Usage of Base URL

Source: https://docs.gofiber.io/client/rest

Demonstrates initializing a client, setting a base URL, and performing a GET request.

```go
cc := client.New()  

cc.SetBaseURL("https://httpbin.org/")  

  

resp, err := cc.Get("/get")  

if err != nil {  

    panic(err)  

}  

  

fmt.Println(string(resp.Body()))
```

--------------------------------

### Install Fiber Monitor

Source: https://docs.gofiber.io/contrib/monitor

Install the Fiber framework and the Monitor contrib package using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/monitor  
```

--------------------------------

### Start SvelteKit Development Server

Source: https://docs.gofiber.io/recipes/sveltekit-embed/template

Run this command to start the development server after installing dependencies. You can also open the app in a new browser tab.

```bash
npm run dev  

  
# or start the server and open the app in a new browser tab  

npm run dev -- --open  

  

```

--------------------------------

### Install MsgPack Library

Source: https://docs.gofiber.io/guide/advance-format

Install either the vmihailenco/msgpack or shamaton/msgpack/v3 library using the go get command.

```go
go get github.com/vmihailenco/msgpack  

# or  

go get github.com/shamaton/msgpack/v3  
```

--------------------------------

### Install Fiber and Fgprof Middleware

Source: https://docs.gofiber.io/contrib/fgprof

Install the Fiber framework and the fgprof contrib middleware using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/fgprof  
```

--------------------------------

### Local Development Setup (Docker)

Source: https://docs.gofiber.io/blog/spa-delivery-with-fiber-v3

Instructions for setting up the React Router SPA example locally using Docker. This is the recommended method for a consistent development environment.

```bash
git clone https://github.com/gofiber/recipes.git
cd recipes/react-router

# Option A: Docker (recommended by recipe)
docker build . -t react-router:latest
docker run -d -p 8080:8080 react-router:latest
```

--------------------------------

### Install sqlc

Source: https://docs.gofiber.io/recipes/sqlc

Installs the sqlc command-line tool. Use 'go install' for Go 1.25+ or 'go get' for older versions.

```bash
# Go 1.25 and above:  
$ go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest  
  
# Legacy Go versions (<1.25):  
go get github.com/sqlc-dev/sqlc/cmd/sqlc
```

--------------------------------

### Install Fiber and Websocket Packages

Source: https://docs.gofiber.io/contrib/websocket

Installs the Fiber framework and the contrib websocket package using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/websocket  
```

--------------------------------

### Start the Application

Source: https://docs.gofiber.io/recipes/entgo-sveltekit

After the build process is complete, use this command to start the application.

```bash
./app
```

--------------------------------

### Install Ristretto Storage Package

Source: https://docs.gofiber.io/storage/ristretto

Install the Ristretto storage implementation for Fiber using the go get command.

```bash
go get github.com/gofiber/storage/ristretto/v2
```

--------------------------------

### Postgres Container Output

Source: https://docs.gofiber.io/recipes/sqlc

Example output showing the PostgreSQL container starting and initializing.

```text
[+] Running 2/0  
 ✔ Network sqlc_default       Created                                                                             0.1s  
 ✔ Container postgres         Created                                                                             0.0s  
Attaching to postgres  
postgres  |  
postgres  | PostgreSQL Database directory appears to contain a database; Skipping initialization  
postgres  |  
postgres  |  
postgres  | 2023-09-28 09:17:50.737 UTC [1] LOG:  starting PostgreSQL 16.0 (Debian 16.0-1.pgdg120+1) on aarch64-unknown-linux-gnu, compiled by gcc (Debian 12.2.0-14) 12.2.0, 64-bit  
postgres  | 2023-09-28 09:17:50.737 UTC [1] LOG:  listening on IPv4 address "0.0.0.0", port 5432  
postgres  | 2023-09-28 09:17:50.737 UTC [1] LOG:  listening on IPv6 address "::", port 5432  
postgres  | 2023-09-28 09:17:50.740 UTC [1] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"  
postgres  | 2023-09-28 09:17:50.751 UTC [30] LOG:  database system was shut down at 2023-09-28 08:50:35 UTC  
postgres  | 2023-09-28 09:17:50.770 UTC [1] LOG:  database system is ready to accept connections  

```

--------------------------------

### Start Minikube

Source: https://docs.gofiber.io/recipes/k8s

Start Minikube for local Kubernetes development.

```bash
minikube start  
```

--------------------------------

### Basic Fiber Listen Usage

Source: https://docs.gofiber.io/api/fiber

Examples of starting the server on specific ports or with preforking enabled.

```go
// Listen on port :8080  

app.Listen(":8080")  

  

// Listen on port :8080 with Prefork  

app.Listen(":8080", fiber.ListenConfig{EnablePrefork: true})  

  

// Custom host  

app.Listen("127.0.0.1:8080")  
```

--------------------------------

### Local Development Setup

Source: https://docs.gofiber.io/blog/build-a-crud-app-with-fiber

Provides commands to clone the Fiber recipes repository and run the gorm-postgres example locally. Assumes default local Postgres settings.

```bash
git clone https://github.com/gofiber/recipes.git
cd recipes/gorm-postgres
go run app.go

```

--------------------------------

### Quick Start CSRF Configuration

Source: https://docs.gofiber.io/middleware/csrf

Demonstrates basic development setup and a secure production configuration for the CSRF middleware.

```go
import (  

    "github.com/gofiber/fiber/v3"  

    "github.com/gofiber/fiber/v3/extractors"  

    "github.com/gofiber/fiber/v3/middleware/csrf"  

)  

  

// Default config (development only)  

app.Use(csrf.New())  

  

// Production config  

app.Use(csrf.New(csrf.Config{  

    CookieName:        "__Host-csrf_",  

    CookieSecure:      true,  

    CookieHTTPOnly:    true,  // false for SPAs  

    CookieSameSite:    "Lax",  

    CookieSessionOnly: true,  

    Extractor:         extractors.FromHeader("X-Csrf-Token"),  

    Session:           sessionStore,  

    // Redaction is enabled by default. Set DisableValueRedaction when you must expose tokens or storage keys in diagnostics.  

    // DisableValueRedaction: true,  

}))
```

--------------------------------

### Installation Commands

Source: https://docs.gofiber.io/storage/rueidis

Commands to initialize a Go module and install the Rueidis storage package.

```bash
go mod init github.com/<user>/<repo>
```

```bash
go get github.com/gofiber/storage/rueidis
```

--------------------------------

### Run Single File Upload Example

Source: https://docs.gofiber.io/recipes/minio

Starts the Go Fiber application for single file uploads.

```bash
cd single  

go run main.go  
```

--------------------------------

### Configure middleware with Use

Source: https://docs.gofiber.io/guide/routing

Examples of matching any request, specific prefixes, multiple prefixes, multiple handlers, and mounting sub-apps.

```go
// Match any request  

app.Use(func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match request starting with /api  

app.Use("/api", func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match requests starting with /api or /home (multiple-prefix support)  

app.Use([]string{"/api", "/home"}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Attach multiple handlers (they run in order; each must call c.Next() to continue)  

app.Use("/api", func(c fiber.Ctx) error {  

    c.Set("X-Custom-Header", "value")  

    return c.Next()  

}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Mount a sub-app  

app.Use("/api", api)  
```

--------------------------------

### Example: Setting and Retrieving Cookies

Source: https://docs.gofiber.io/client/request

Demonstrates setting cookies via a map and performing a GET request.

```go
req := client.AcquireRequest()  

defer client.ReleaseRequest(req)  

  

req.SetCookies(map[string]string{  

    "cookie1": "value1",  

    "cookie2": "value2",  

})  

  

resp, err := req.Get("https://httpbin.org/cookies")  

if err != nil {  

    panic(err)  

}  

  

fmt.Println(string(resp.Body()))
```

```json
{
  "cookies": {
    "test": "123"
  }
}
```

--------------------------------

### Run Multiple File Upload Example

Source: https://docs.gofiber.io/recipes/minio

Starts the Go Fiber application for multiple file uploads.

```bash
cd multiple  

go run main.go  
```

--------------------------------

### Importing and Initializing Storage

Source: https://docs.gofiber.io/storage/azureblob

How to import the package and initialize the storage client with default or custom configurations.

```go
import "github.com/gofiber/storage/azureblob/v2"
```

```go
// Initialize default config  

store := azureblob.New()  

  

// Initialize custom config  

store := azureblob.New(azureblob.Config{  

    Account:   "test",  

    Container: "test",  

    Credentials: Credentials{  

        Account: "test",  

        Key:     "YXp1cml0ZWtleQo=",  

    },  

})
```

--------------------------------

### Clone the Fiber Server-Timing Recipe Repository

Source: https://docs.gofiber.io/recipes/server-timing

Clone the repository to get started with the Server-Timing example. Navigate into the cloned directory.

```bash
git clone https://github.com/gofiber/recipes.git  

cd recipes/server-timing  
```

--------------------------------

### Basic WebSocket Event Server Setup

Source: https://docs.gofiber.io/contrib/websocket/event

Set up a basic Fiber WebSocket server that echoes received messages back to the client. This example demonstrates event registration, connection handling, and message emission.

```go
package main

import (
	"log"

	"github.com/gofiber/contrib/v3/websocket"
	"github.com/gofiber/contrib/v3/websocket/event"
	"github.com/gofiber/fiber/v3"
)

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

	app.Use("/ws", func(c fiber.Ctx) error {
		if websocket.IsWebSocketUpgrade(c) {
			return c.Next()
		}
		return fiber.ErrUpgradeRequired
	})

	event.On(event.EventMessage, func(ep *event.EventPayload) {
		ep.Kws.Emit([]byte("echo: "+string(ep.Data)), event.TextMessage)
	})

	app.Get("/ws/:id", event.New(func(kws *event.Websocket) {
		// kws.Params / kws.Locals / kws.Query / kws.Cookies wrap the Fiber
		// request context captured at upgrade time.
		kws.SetAttribute("user_id", kws.Params("id"))
	}))

	log.Fatal(app.Listen(":3000"))
}

```

--------------------------------

### Initialize Go Module and Install Firestore Driver

Source: https://docs.gofiber.io/storage/firestore

Commands to set up the project and install the storage package.

```bash
go mod init github.com/<user>/<repo>
```

```bash
go get github.com/gofiber/storage/firestore
```

--------------------------------

### Clone the GORM recipes repository

Source: https://docs.gofiber.io/recipes/gorm

Clone the repository to get the GORM example code. Ensure you have Go 1.25 or higher installed.

```bash
git clone https://github.com/gofiber/recipes.git  

cd recipes/gorm  
```

--------------------------------

### Clone Fiber JWT Recipe Repository

Source: https://docs.gofiber.io/recipes/jwt

Clone the Fiber recipes repository to get started with the JWT example. Navigate into the JWT directory.

```bash
git clone https://github.com/gofiber/recipes.git  

cd recipes/jwt  
```

--------------------------------

### Initialize New Client

Source: https://docs.gofiber.io/client/rest

Creates and returns a new Client instance.

```go
func New() *Client  
```

--------------------------------

### Unit Test Example for Root Route

Source: https://docs.gofiber.io/recipes/unit-test

This snippet demonstrates how to use `app.Test` to simulate a GET request to the root route and assert the response status code and body. Ensure the `Setup()` function is correctly implemented to initialize your Fiber app.

```go
package main

import (
    "io"
    "net/http"
    "testing"

    "github.com/gofiber/fiber/v3"
    "github.com/stretchr/testify/assert"
)

func TestIndexRoute(t *testing.T) {
    // Setup the app as it is done in the main function
    app := Setup()

    // Create a new HTTP request
    req, err := http.NewRequest("GET", "/", nil)
    assert.Nil(t, err)

    // Perform the request using app.Test
    res, err := app.Test(req, fiber.TestConfig{Timeout: 0, FailOnTimeout: false})
    defer res.Body.Close()

    // Verify that no error occurred
    assert.Nil(t, err)

    // Verify the status code
    assert.Equal(t, 200, res.StatusCode)

    // Read the response body
    body, err := io.ReadAll(res.Body)
    assert.Nil(t, err)

    // Verify the response body
    assert.Equal(t, "OK", string(body))
}

```

--------------------------------

### Create Hello World Server

Source: https://docs.gofiber.io/

A minimal Fiber application setup listening on port 3000.

```go
package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
)

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

    app.Get("/", func(c fiber.Ctx) error {
        return c.SendString("Hello, World!")
    })

    log.Fatal(app.Listen(":3000"))
}
```

--------------------------------

### Install Validator Package

Source: https://docs.gofiber.io/guide/validation

Install the go-playground/validator package via go get.

```bash
go get github.com/go-playground/validator/v10
```

--------------------------------

### Install CBOR Library

Source: https://docs.gofiber.io/guide/advance-format

Install the fxamacker/cbor/v2 library using the go get command.

```go
go get github.com/fxamacker/cbor/v2  
```

--------------------------------

### Install SurrealDB Storage

Source: https://docs.gofiber.io/storage/surrealdb

Command to install the SurrealDB storage package via go get.

```bash
go get github.com/gofiber/storage/surrealdb  
```

--------------------------------

### Basic Static File Server Setup

Source: https://docs.gofiber.io/blog/static-server-with-fiber-v3

A minimal setup for serving static files from a local directory. This is suitable for local development and internal tools.

```go
app := fiber.New()  
app.Get("/*", static.New("./files"))  
log.Fatal(app.Listen(":3000"))  
```

--------------------------------

### Installation Commands

Source: https://docs.gofiber.io/storage/arangodb

Commands to initialize a Go module and install the ArangoDB storage package.

```bash
go mod init github.com/<user>/<repo>  
```

```bash
go get github.com/gofiber/storage/arangodb/v2  
```

--------------------------------

### Initialize SurrealDB Storage

Source: https://docs.gofiber.io/storage/surrealdb

Examples for initializing the storage with default or custom configurations.

```go
// Initialize default config  

store := surrealdb.New()  

  

// Initialize SurrealDB storage with custom config  

store := surrealdb.New(Config{  

ConnectionString: "ws://localhost:8000",  

Namespace:        "fiber_storage",  

Database:         "fiber_storage",  

Username:         "root",  

Password:         "root",  

Access:           "full",  

Scope:            "all",  

DefaultTable:     "fiber_storage",  

GCInterval:       time.Second * 10,  

})  
```

--------------------------------

### Install WebSocket Package

Source: https://docs.gofiber.io/contrib/websocket/event

Install the Fiber websocket contrib package using go get.

```go
go get -u github.com/gofiber/contrib/v3/websocket
```

--------------------------------

### Install Swaggo Middleware

Source: https://docs.gofiber.io/contrib/swaggo

Installs the swaggo middleware for Fiber v3 using go get.

```bash
go get github.com/gofiber/contrib/v3/swaggo
```

--------------------------------

### Retry Configuration Examples

Source: https://docs.gofiber.io/addon/retry

Examples showing default and custom configuration initialization for the retry addon.

```go
retry.NewExponentialBackoff()  
```

```go
retry.NewExponentialBackoff(retry.Config{  

    InitialInterval: 2 * time.Second,  

    MaxBackoffTime:  64 * time.Second,  

    Multiplier:      2.0,  

    MaxRetryCount:   15,  

})  
```

--------------------------------

### Basic OPA Middleware Usage

Source: https://docs.gofiber.io/contrib/opa

Demonstrates setting up OPA middleware with a simple Rego policy and custom input creation.

```go
package main  
  
import (  
    "bytes"  

    "github.com/gofiber/fiber/v3"  
    "github.com/gofiber/contrib/v3/opa"  
)  
  
func main() {  
    app := fiber.New()  

    module := `  
package example.authz  
  
default allow := false  
  
allow if {  
    input.method == "GET"  
}  
`  

    cfg := opa.Config{  
        RegoQuery:             "data.example.authz.allow",  
        RegoPolicy:            bytes.NewBufferString(module),  
        IncludeQueryString:    true,  
        DeniedStatusCode:      fiber.StatusForbidden,  
        DeniedResponseMessage: "status forbidden",  
        IncludeHeaders:        []string{"Authorization"},  
        InputCreationMethod:   func(ctx fiber.Ctx) (map[string]interface{}, error) {  
            return map[string]interface{}{  
                "method": ctx.Method(),  
                "path": ctx.Path(),  
            }, nil  
        },  
    }  
    app.Use(opa.New(cfg))  

    app.Get("/", func(ctx fiber.Ctx) error {  
        return ctx.SendStatus(200)  
    })  

    app.Listen(":8080")  
}
```

--------------------------------

### Install OpenTelemetry Middleware

Source: https://docs.gofiber.io/contrib/otel

Install the OpenTelemetry contrib package for Fiber using go get.

```go
go get -u github.com/gofiber/contrib/v3/otel
```

--------------------------------

### Hello World Comparison

Source: https://docs.gofiber.io/blog/express-to-fiber-guide

Basic server setup and route definition in Express versus Fiber v3.

```javascript
// Express  

const express = require('express');  

const app = express();  

  

app.get('/', (req, res) => {  

    res.send('Hello, World!');  

});  

  

app.listen(3000);  
```

```go
// Fiber v3  

package main  

  

import "github.com/gofiber/fiber/v3"  

  

func main() {  

    app := fiber.New()  

  

    app.Get("/", func(c fiber.Ctx) error {  

        return c.SendString("Hello, World!")  

    })  

  

    app.Listen(":3000")  

}  
```

--------------------------------

### Install LoadShed Middleware

Source: https://docs.gofiber.io/contrib/loadshed

Install the Fiber framework and the LoadShed middleware using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/loadshed  
```

--------------------------------

### Install Coraza Middleware

Source: https://docs.gofiber.io/contrib/coraza

Install the Fiber framework and the Coraza middleware using go get.

```go
go get github.com/gofiber/fiber/v3  

go get github.com/gofiber/contrib/v3/coraza  
```

--------------------------------

### Full Websocket Example

Source: https://docs.gofiber.io/contrib/websocket

A complete example demonstrating how to set up a Fiber application with WebSocket support, including connection handling, message reading, and writing.

```go
package main  

import  

    "log"  

    "github.com/gofiber/fiber/v3"  

    "github.com/gofiber/contrib/v3/websocket"  

)

func main() {

    app := fiber.New()  


    app.Use("/ws", func(c fiber.Ctx) error {

        // IsWebSocketUpgrade returns true if the client  

        // requested upgrade to the WebSocket protocol.  

        if websocket.IsWebSocketUpgrade(c) {

            c.Locals("allowed", true)

            return c.Next()

        }

        return fiber.ErrUpgradeRequired

    })


    app.Get("/ws/:id", websocket.New(func(c *websocket.Conn) {

        // c.Locals is added to the *websocket.Conn  

        log.Println(c.Locals("allowed"))  // true  

        log.Println(c.Params("id"))       // 123  

        log.Println(c.Query("v"))         // 1.0  

        log.Println(c.Cookies("session")) // ""  


        // websocket.Conn bindings https://pkg.go.dev/github.com/fasthttp/websocket?tab=doc#pkg-index  

        var (  

            mt  int  

            msg []byte  

            err error  

        )

        for {  

            if mt, msg, err = c.ReadMessage(); err != nil {

                log.Println("read:", err)

                break

            }

            log.Printf("recv: %s", msg)


            if err = c.WriteMessage(mt, msg); err != nil {

                log.Println("write:", err)

                break

            }

        }


    }))


    log.Fatal(app.Listen(":3000"))

    // Access the websocket server: ws://localhost:3000/ws/123?v=1.0  

    // https://www.websocket.org/echo.html  

}

  
```

--------------------------------

### Start RabbitMQ Manually

Source: https://docs.gofiber.io/recipes/rabbitmq

Commands to start RabbitMQ in a Docker container as part of a manual setup.

```bash
make docker.network

make docker.rabbitmq
```

--------------------------------

### Configure and use the Fiber client

Source: https://docs.gofiber.io/whats_new

Shows how to initialize a client with base configurations and perform a request with per-request overrides.

```go
cc := client.New().  
    SetBaseURL("https://api.service.local").  
    AddHeader("Authorization", "Bearer <token>").  
    SetTimeout(5 * time.Second).  
    SetPathParam("tenant", "acme")  

  

resp, err := cc.Get("/users/:tenant/:id", client.Config{  
    PathParam:              map[string]string{"id": "42"},  
    Param:                  map[string]string{"include": "profile"},  
    DisablePathNormalizing: true,  
})  

if err != nil {  
    panic(err)  
}  

defer resp.Close()  

fmt.Println(resp.StatusCode(), resp.String())  



```

--------------------------------

### Install Jet Template Engine

Source: https://docs.gofiber.io/template/jet

Install the Jet template engine using go get. This command fetches and installs the specified version of the package.

```go
go get github.com/gofiber/template/jet/v3  

```

--------------------------------

### Install MSSQL Storage Driver

Source: https://docs.gofiber.io/storage/mssql

Install the MSSQL storage implementation for Fiber using go get.

```bash
go get github.com/gofiber/storage/mssql/v2
```

--------------------------------

### Basic Route Examples

Source: https://docs.gofiber.io/

Examples of simple route handlers and routes using path parameters.

```go
// Respond with "Hello, World!" on root path "/"  

app.Get("/", func(c fiber.Ctx) error {  

    return c.SendString("Hello, World!")  

})  
```

```go
// GET http://localhost:3000/hello%20world  

  

app.Get("/:value", func(c fiber.Ctx) error {  

    return c.SendString("value: " + c.Params("value"))  

    // => Response: "value: hello world"  

})  
```

--------------------------------

### Initialize Neo4j Storage

Source: https://docs.gofiber.io/storage/neo4j

Examples for initializing the storage driver with default or custom configurations.

```go
// Initialize default config

store := neo4j.New()



// Initialize custom config

store := neo4j.New(neo4j.Config{

 DB:              driver,

 Node:            "fiber_storage",

 Reset:           false,

 GCInterval:      10 * time.Second,

})
```

--------------------------------

### Install Etcd Storage Driver

Source: https://docs.gofiber.io/storage/etcd

Install the etcd storage implementation for GoFiber using go get.

```bash
go get github.com/gofiber/storage/etcd/v2
```

--------------------------------

### Cloning and Running the File Server Example

Source: https://docs.gofiber.io/blog/static-server-with-fiber-v3

Instructions to clone the Fiber recipes repository, navigate to the file server example, and run it locally.

```bash
git clone https://github.com/gofiber/recipes.git  
cd recipes/file-server  
go run main.go  
```

--------------------------------

### Install Testcontainers Package

Source: https://docs.gofiber.io/contrib/testcontainers

Install the Fiber v3 and the Testcontainers contrib package using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/testcontainers  
```

--------------------------------

### Start Worker Manually

Source: https://docs.gofiber.io/recipes/rabbitmq

Command to start the RabbitMQ worker process in a separate terminal during manual setup.

```bash
make docker.worker
```

--------------------------------

### Initialize and Use Fiber Client

Source: https://docs.gofiber.io/client/rest

Demonstrates creating a client instance, setting a timeout, and performing a GET request.

```go
package main  
  
  

import (  

    "fmt"  

    "time"  

  

    "github.com/gofiber/fiber/v3/client"  

)  

  

func main() {  

    cc := client.New()  

    cc.SetTimeout(10 * time.Second)  

  

    // Send a GET request  

    resp, err := cc.Get("https://httpbin.org/get")  

    if err != nil {  

        panic(err)  

    }  

  

    fmt.Printf("Status: %d\n", resp.StatusCode())  

    fmt.Printf("Body: %s\n", string(resp.Body()))  

}  
```

--------------------------------

### Install Amber Template Engine

Source: https://docs.gofiber.io/template/amber

Install the Amber template engine for Fiber v3 using go get.

```go
go get github.com/gofiber/template/amber/v3
```

--------------------------------

### Basic Zerolog Integration Example

Source: https://docs.gofiber.io/contrib/zerolog

Demonstrates how to set up Fiber with Zerolog logging using a custom logger instance. This example logs all incoming requests and errors.

```go
package main  

  

import (  

    "os"  

  

    middleware "github.com/gofiber/contrib/v3/zerolog"  

    "github.com/gofiber/fiber/v3"  

    "github.com/rs/zerolog"  

)  

  

func main() {  

    app := fiber.New()  

    logger := zerolog.New(os.Stderr).With().Timestamp().Logger()  

  

    app.Use(middleware.New(middleware.Config{  

        Logger: &logger,  

    }))  

  

    app.Get("/", func(c fiber.Ctx) error {  

        return c.SendString("Hello, World!")  

    })  

  

    if err := app.Listen(":3000"); err != nil {  

        logger.Fatal().Err(err).Msg("Fiber app error")  

    }  

}  

  

```

--------------------------------

### Install Valkey Storage

Source: https://docs.gofiber.io/storage/valkey

Commands to initialize a Go module and install the Valkey storage driver.

```bash
go mod init github.com/<user>/<repo>
```

```bash
go get github.com/gofiber/storage/valkey
```

--------------------------------

### Install Cassandra Storage Driver

Source: https://docs.gofiber.io/storage/cassandra

Command to install the Cassandra storage driver for Fiber using go get.

```bash
go get github.com/gofiber/storage/cassandra
```

--------------------------------

### Full Sentry Integration Example

Source: https://docs.gofiber.io/contrib/sentry

Demonstrates initializing Sentry, configuring the middleware, and using GetHubFromContext to add tags and capture messages within Fiber routes.

```go
package main  

  

import (  

    "fmt"  

    "log"  

  

    sdk "github.com/getsentry/sentry-go"  

    fiberSentry "github.com/gofiber/contrib/v3/sentry"  

    "github.com/gofiber/fiber/v3"  

    "github.com/gofiber/fiber/v3/utils"  

)  

  

func main() {  

    _ = sdk.Init(sdk.ClientOptions{  

        Dsn: "",  

        BeforeSend: func(event *sdk.Event, hint *sdk.EventHint) *sdk.Event {  

            if hint.Context != nil {  

                if c, ok := hint.Context.Value(sdk.RequestContextKey).(fiber.Ctx); ok {  

                    // You have access to the original Context if it panicked  

                    fmt.Println(utils.ImmutableString(c.Hostname()))  

                }  

            }  

            fmt.Println(event)  

            return event  

        },  

        Debug:            true,  

        AttachStacktrace: true,  

    })  

  

    app := fiber.New()  

  

    app.Use(fiberSentry.New(fiberSentry.Config{  

        Repanic:         true,  

        WaitForDelivery: true,  

    }))  

  

    enhanceSentryEvent := func(c fiber.Ctx) error {  

        if hub := fiberSentry.GetHubFromContext(c); hub != nil {  

            hub.Scope().SetTag("someRandomTag", "maybeYouNeedIt")  

        }  

        return c.Next()  

    }  

  

    app.All("/foo", enhanceSentryEvent, func(c fiber.Ctx) error {  

        panic("y tho")  

    })  

  

    app.All("/", func(c fiber.Ctx) error {  

        if hub := fiberSentry.GetHubFromContext(c); hub != nil {  

            hub.WithScope(func(scope *sdk.Scope) {  

                scope.SetExtra("unwantedQuery", "someQueryDataMaybe")  

                hub.CaptureMessage("User provided unwanted query string, but we recovered just fine")  

            })  

        }  

        return c.SendStatus(fiber.StatusOK)  

    })  

  

    log.Fatal(app.Listen(":3000"))  

}  
```

--------------------------------

### Configure TLS with Certificate Files

Source: https://docs.gofiber.io/api/fiber

Starts an HTTPS server using provided certificate and key file paths.

```go
app.Listen(":443", fiber.ListenConfig{CertFile: "./cert.pem", CertKeyFile: "./cert.key"})
```

--------------------------------

### Install Zap Logging Middleware

Source: https://docs.gofiber.io/contrib/zap

Install the Fiber Zap middleware and Zap logger using go get.

```go
go get -u github.com/gofiber/fiber/v3  
go get -u github.com/gofiber/contrib/v3/zap  
go get -u go.uber.org/zap  
```

--------------------------------

### Initialize Clickhouse Storage

Source: https://docs.gofiber.io/storage/clickhouse

Examples of initializing the storage driver with default, custom, and TLS configurations.

```go
import "github.com/gofiber/storage/clickhouse"  

  

// Initialize default config, to connect to localhost:9000 using the memory engine and with a clean table.  

store, err := clickhouse.New(clickhouse.Config{  

    Host: "localhost",  

    Port: 9000,  

    Clean: true,  

})  

  

// Initialize custom config to connect to a different host/port and use custom engine and with clean table.  

store, err := clickhouse.New(clickhouse.Config{  

    Host: "some-ip-address",  

    Port: 9000,  

    Engine: clickhouse.MergeTree,  

    Clean: true,  

})  

  

// Initialize to connect with TLS enabled with your own tls.Config and with clean table.  

tlsConfig := config := &tls.Config{...}  

  

store, err := clickhouse.New(clickhouse.Config{  

    Host: "some-ip-address",  

    Port: 9000,  

    Clean: true,  

    TLSConfig: tlsConfig,  

})
```

--------------------------------

### Initialize Ristretto Storage with Custom Configuration

Source: https://docs.gofiber.io/storage/ristretto

This example demonstrates how to initialize the Ristretto storage with custom configuration values for NumCounters, MaxCost, and BufferItems.

```go
import "github.com/gofiber/storage/ristretto/v2"

// Initialize custom config
store := ristretto.New(ristretto.Config{
  NumCounters: 1e7, // number of keys to track frequency of (10M).
  MaxCost:     1 << 30, // maximum cost of cache (1GB).
  BufferItems: 64, // number of keys per Get buffer.
})
```

--------------------------------

### Install Fiber i18n Package

Source: https://docs.gofiber.io/contrib/i18n

Install the Fiber framework and the i18n contrib package using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/i18n  
```

--------------------------------

### Basic HTML Template Engine Setup

Source: https://docs.gofiber.io/template

Set up the HTML template engine with a specified directory and extension. Supports reloading templates and debugging.

```go
package main  
  
import (  
	"log"  

        "github.com/gofiber/fiber/v3"  
  
	// To use a specific template engine, import as shown below:  
	// "github.com/gofiber/template/pug/v3"  

	// "github.com/gofiber/template/mustache/v3"  

	// etc..  
  
	// In this example we use the html template engine  
	"github.com/gofiber/template/html/v3"
)

func main() {  
	// Create a new engine by passing the template folder  
	// and template extension using <engine>.New(dir, ext string)  
	engine := html.New("./views", ".html")  

  	// We also support the http.FileSystem interface  
	// See examples below to load templates from embedded files  
	engine := html.NewFileSystem(http.Dir("./views"), ".html")  

  	// Reload the templates on each render, good for development  
	engine.Reload(true) // Optional. Default: false  

  	// Debug will print each template that is parsed, good for debugging  
	engine.Debug(true) // Optional. Default: false  

  	// Layout defines the variable name that is used to yield templates within layouts  
	engine.Layout("embed") // Optional. Default: "embed"  

  	// Delims sets the action delimiters to the specified strings  
	engine.Delims("{{", "}}") // Optional. Default: engine delimiters  

  	// AddFunc adds a function to the template's global function map.  
	engine.AddFunc("greet", func(name string) string {  
		return "Hello, " + name + "!"  
	})  

  	// After you created your engine, you can pass it to Fiber's Views Engine  
	app := fiber.New(fiber.Config{  
		Views: engine,  
	})

	// To render a template, you can call the ctx.Render function  
	// Render(tmpl string, values interface{}, layout ...string)  
	app.Get("/", func(c fiber.Ctx) error {  
		return c.Render("index", fiber.Map{  
			"Title": "Hello, World!",  
		})
	})

	// Render with layout example  
	app.Get("/layout", func(c fiber.Ctx) error {  
		return c.Render("index", fiber.Map{  
			"Title": "Hello, World!",  
		}, "layouts/main")  
	})

	log.Fatal(app.Listen(":3000"))  
}
  

```

--------------------------------

### Main Application Setup in Go Fiber

Source: https://docs.gofiber.io/recipes/clean-architecture

Initializes a Go Fiber application, sets up the book repository and service, and registers book-related routes. The application listens on port 3000.

```Go
package main

import (
    "clean-architecture/api/routes"
    "clean-architecture/pkg/book"
    "github.com/gofiber/fiber/v3"
)

func main() {
    app := fiber.New()
    bookRepo := book.NewRepo(collection)
    bookService := book.NewService(bookRepo)
    routes.BookRouter(app, bookService)
    app.Listen(":3000")
}

```

--------------------------------

### Install Mustache Template Engine

Source: https://docs.gofiber.io/template/mustache

Install the v4 version of the Fiber Mustache template engine using go get.

```go
go get github.com/gofiber/template/mustache/v4
```

--------------------------------

### Install Cloudflare KV Storage

Source: https://docs.gofiber.io/storage/cloudflarekv

Install the Cloudflare KV storage implementation for your Go project using go get.

```go
go get github.com/gofiber/storage/cloudflarekv
```

--------------------------------

### Create Configured Client Instance with Factory

Source: https://docs.gofiber.io/blog/fiber-v3-client-deep-dive

Demonstrates creating a reusable client instance using a factory function, centralizing base URL, timeout, and default headers for outbound calls.

```go
import (

    "time"

    "github.com/gofiber/fiber/v3/client"

)

func NewUsersClient() *client.Client {

    return client.New().

        SetBaseURL("https://users.internal").

        SetTimeout(1500 * time.Millisecond).

        SetHeader("X-Caller-Service", "billing-api")

}
```

--------------------------------

### Install Fiber and HCaptcha Middleware

Source: https://docs.gofiber.io/contrib/hcaptcha

Installs the necessary Fiber v3 and HCaptcha contrib packages using go get.

```go
go get -u github.com/gofiber/fiber/v3  
go get -u github.com/gofiber/contrib/v3/hcaptcha  
```

--------------------------------

### Install Circuit Breaker Package

Source: https://docs.gofiber.io/contrib/circuitbreaker

Install the Fiber framework and the circuit breaker contrib package using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/circuitbreaker  
```

--------------------------------

### View Service Startup Output

Source: https://docs.gofiber.io/whats_new

Example console output showing registered services running during application startup.

```text
$ go run . -v  
  
    _______ __  

   / ____(_) /_  ___  _____  

  / /_  / / __ \/ _ \/ ___/  

 / __/ / / /_/ /  __/ /  

/_/   /_/_.___/\___/_/          v3.0.0  

--------------------------------------------------  

INFO Server started on:         http://127.0.0.1:3000 (bound on host 0.0.0.0 and port 3000)  

INFO Services:     2  

INFO   🧩 [ RUNNING ] postgres:latest  

INFO   🧩 [ RUNNING ] redis:latest  

INFO Total handlers count:      2  

INFO Prefork:                   Disabled  

INFO PID:                       12279  

INFO Total process count:       1
```

--------------------------------

### GraphQL GET request example

Source: https://docs.gofiber.io/recipes/graphql

Send a GraphQL query using a URL-encoded 'query' parameter via a GET request.

```bash
curl 'http://localhost:9090/?query=query%7Bhello%7D'  
```

--------------------------------

### Installation Commands

Source: https://docs.gofiber.io/storage/azureblob

Commands to initialize a Go module and install the Azure Blob storage package.

```bash
go mod init github.com/<user>/<repo>
```

```bash
go get github.com/gofiber/storage/azureblob/v2
```

--------------------------------

### Install Sentry Dependencies

Source: https://docs.gofiber.io/contrib/sentry

Install the necessary Fiber, Sentry contrib, and Sentry Go SDK packages using go get.

```go
go get -u github.com/gofiber/fiber/v3  

go get -u github.com/gofiber/contrib/v3/sentry  

go get -u github.com/getsentry/sentry-go  
```

--------------------------------

### Initialize MongoDB Storage

Source: https://docs.gofiber.io/storage/mongodb

Examples for initializing the storage driver using default settings, custom configuration, or a connection URI.

```go
// Initialize default config  

store := mongodb.New()  

  

// Initialize custom config  

store := mongodb.New(mongodb.Config{  

	Host:       "127.0.0.1",  

	Port:       27017,  

	Database:   "fiber",  

	Collection: "fiber_storage",  

	Reset:      false,  

})  

  

// Initialize custom config using connection string  

store := mongodb.New(mongodb.Config{  

	ConnectionURI: "mongodb://user:password@127.0.0.1:27017",  

	Database:   	 "fiber",  

	Collection: 	 "fiber_storage",  

	Reset:      	 false,  

})  
```

--------------------------------

### Install HTML Template Engine

Source: https://docs.gofiber.io/template/html

Install the Fiber HTML template engine using go get. This command fetches the v3 version of the package.

```go
go get github.com/gofiber/template/html/v3
```

--------------------------------

### Install Handlebars Template Engine

Source: https://docs.gofiber.io/template/handlebars

Install the Fiber Handlebars template engine using go get. Ensure you are using a supported Go version.

```go
go get github.com/gofiber/template/handlebars/v3
```

--------------------------------

### Install Couchbase Storage Driver

Source: https://docs.gofiber.io/storage/couchbase

Installs the Couchbase storage driver for Fiber using go get. Ensure you have initialized Go modules first.

```bash
go get github.com/gofiber/storage/couchbase/v2
```

--------------------------------

### Install Minio Driver and Server

Source: https://docs.gofiber.io/storage/minio

Commands to install the Go package and run a local Minio instance via Docker.

```bash
go get github.com/gofiber/storage/minio
```

```bash
docker run -d --restart always -p 9000:9000 -p 9001:9001 --name storage-minio --volume=minio:/var/lib/minio -e MINIO_ROOT_USER='minio-user' -e MINIO_ROOT_PASSWORD='minio-password' minio/minio server --console-address ":9001" /var/lib/minio
```

--------------------------------

### Install Swagger UI Middleware

Source: https://docs.gofiber.io/contrib/swaggerui

Install the Swagger UI middleware package using go get. Ensure you have initialized a Go module first.

```bash
go get github.com/gofiber/contrib/v3/swaggerui
```

--------------------------------

### Build and Start Docker Containers

Source: https://docs.gofiber.io/recipes/auth-docker-postgres-jwt

Build the Docker images and start the application and database containers.

```bash
docker-compose build  

docker-compose up  
```

--------------------------------

### Get Book by ID API Request

Source: https://docs.gofiber.io/recipes/gorm

Example cURL command to retrieve a specific book by its ID. This sends a GET request to the /api/v1/book/:id endpoint.

```bash
curl -X GET http://localhost:3000/api/v1/book/1  
```

--------------------------------

### Get All Products Request

Source: https://docs.gofiber.io/recipes/hexagonal

Example cURL request to retrieve all products from the API.

```bash
curl -X GET http://localhost:8080/api/v1/products  
```

--------------------------------

### Middleware Usage Examples

Source: https://docs.gofiber.io/api/app

Examples of mounting middleware on specific paths, multiple paths, or attaching multiple handlers.

```go
// Match any request  

app.Use(func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match request starting with /api  

app.Use("/api", func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match requests starting with /api or /home (multiple-prefix support)  

app.Use([]string{"/api", "/home"}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Attach multiple handlers (they run in order; each must call c.Next() to continue)  

app.Use("/api", func(c fiber.Ctx) error {  

    c.Set("X-Custom-Header", "value")  

    return c.Next()  

}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Mount a sub-app  

app.Use("/api", api)
```

--------------------------------

### Clone the Repository

Source: https://docs.gofiber.io/recipes/auth-docker-postgres-jwt

Clone the Fiber recipes repository to get the example code.

```bash
git clone https://github.com/gofiber/recipes.git  

cd recipes/auth-docker-postgres-jwt  
```

--------------------------------

### Install Ace Template Engine

Source: https://docs.gofiber.io/template/ace

Install the Ace template engine using go get. This command fetches the latest version of the Ace template engine for GoFiber.

```go
go get github.com/gofiber/template/ace/v3
```
Tokens:
Raw