Understanding Golang Fiber: From Basic Concepts to Application Architecture

The Secret Behind Fiber Performance: Fasthttp Architecture

mkdir learn-golang-fiber
cd learn-golang-fiber
go mod init learn-golang-fiber

go get -u github.com/gofiber/fiber/v2

package main

import (
	"log"

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

func main() {
	// 1. Create a new Fiber application instance
	app := fiber.New(fiber.Config{
		Prefork: false, // Change to true if you want to take full advantage of the multi-core architecture
		CaseSensitive: true, // Differentiate between /user and /User URLs
		StrictRouting: true, // Differentiate between /user/ and /user URLs
		AppName: "My Fiber Application v1.0",
	})

	// 2. Basic Route Definition
	app.Get("/", func(c *fiber.Ctx) error {
		return c.SendString("Welcome to the World of Golang Fiber!")
	})

	// 3. Running the Server on Port 3000
	log.Fatal(app.Listen(":3000"))
}

app.Get("/api/products", getProductsHandler)
app.Post("/api/products", createProductHandler)
app.Put("/api/products/:id", updateProductHandler)
app.Delete("/api/products/:id", deleteProductHandler)
app.Patch("/api/products/:id", partialUpdateProductHandler)

// Endpoint: GET /users/1024
app.Get("/users/:id", func(c *fiber.Ctx) error {
	userId := c.Params("id")
	return c.SendString("Display user data with ID: " + userId)
})

// Optional Parameters (question mark ?)
// Endpoint: GET /flights/JAKARTA-BALI or /flights/
app.Get("/flights/:route?", func(c *fiber.Ctx) error {
	if c.Params("route") != "" {
		return c.SendString("Flight route: " + c.Params("route"))
	}
	return c.SendString("Displays the entire flight route")
})

// Parameter Wildcard (asterisk *)
// Endpoint: GET /files/documents/pdf/report.pdf
app.Get("/files/*", func(c *fiber.Ctx) error {
	filePath := c.Params("*")
	return c.SendString("Open file in path: " + filePath)
})

app.Get("/search", func(c *fiber.Ctx) error {
	keyword := c.Query("keyword", "default_keyword") // "default_keyword" if not specified
	page := c.Query("page", "1")

	return c.JSON(fiber.Map{
		"keyword": keyword,
		"page": page,
	})
})

func setupRoutes(app *fiber.App) {
	// Group API v1
	v1 := app.Group("/api/v1")

	v1.Get("/users", getAllUsers)
	v1.Post("/users", createUser)

	// Sub-group for Product Module
	products := v1.Group("/products")
	products.Get("/", getAllProducts)
	products.Get("/:id", getProductById)
}

type CreateUserRequest struct {
	Name string `json:"name" form:"name"`
	Email string `json:"email" form:"email"`
	Password string `json:"password" form:"password"`
}

app.Post("/api/users", func(c *fiber.Ctx) error {
	// Struct instantiation
	req := new(CreateUserRequest)

	// Parse body to struct
	if err := c.BodyParser(req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": true,
			"message": "Invalid request body format",
		})
	}

	// Process business logic (e.g. save to database)...

	return c.Status(fiber.StatusCreated).JSON(fiber.Map{
		"error": false,
		"message": "User successfully created",
		"data": req,
	})
})

package main

import (
	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"
)

type RegisterDTO struct {
	Username string `json:"username" validate:"required,min=3,max=20"`
	Email string `json:"email" validate:"required,email"`
	Age int `json:"age" validate:"gte=18,lte=60"`
}

var validate = validator.New()

func registerHandler(c *fiber.Ctx) error {
	dto := new(RegisterDTO)

	if err := c.BodyParser(dto); err != nil {
		return c.Status(fiber.StatusBadRequest).SendString(err.Error())
	}

	// Run Validation
	if err := validate.Struct(dto); err != nil {
		return c.Status(fiber.StatusUnprocessableEntity).JSON(fiber.Map{
			"message": "Validation failed",
			"details": err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(fiber.Map{
		"message": "Registration successful!",
	})
}

Request ---> [ Middleware 1 ] ---> [ Middleware 2 ] ---> [ Route Handler ]
                                                                 |
Response <--- [ Middleware 1 ] <--- [ Middleware 2 ] <-----+

package main

import (
	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/middleware/cors"
	"github.com/gofiber/fiber/v2/middleware/logger"
	"github.com/gofiber/fiber/v2/middleware/recover"
)

func setupMiddleware(app *fiber.App) {
	// 1. Logger: Logs every request in the terminal
	app.Use(logger.New(logger.Config{
		Format: "[${time}] ${status} - ${latency} ${method} ${path}\n",
	}))

	// 2. Recover: Prevents server crashes if a panic occurs in the code
	app.Use(recover.New())

	// 3. CORS: Allow access from specific Frontend domains
	app.Use(cors.New(cors.Config{
		AllowOrigins: "https://myfrontend.com, https://localhost:3000",
		AllowHeaders: "Origin, Content-Type, Accept, Authorization",
		AllowMethods: "GET, POST, PUT, DELETE",
	}))
}

// Middleware to check the Api-Key Header
func ApiKeyMiddleware() fiber.Handler {
	return func(c *fiber.Ctx) error {
		apiKey := c.Get("X-API-KEY")

		if apiKey != "SUPER-123-SECRET" {
			return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
				"error": "Access Denied: Invalid API Key",
			})
		}

		// Continue to the next Middleware or Handler
		return c.Next()
	}
}

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

	// Deploy custom middleware on protected routes
	api := app.Group("/api", ApiKeyMiddleware())

	api.Get("/dashboard", func(c *fiber.Ctx) error {
		return c.SendString("Congratulations, you have successfully accessed the protected dashboard!")
	})

	app.Listen(":3000")
}

package main

import (
	"errors"
	"github.com/gofiber/fiber/v2"
)

func main() {
	app := fiber.New(fiber.Config{
		// Custom Centralized Error Handler
		ErrorHandler: func(c *fiber.Ctx, err error) error {
			// Default status code is 500 (Internal Server Error)
			code := fiber.StatusInternalServerError

			// Check whether the error is of type *fiber.Error
			var e *fiber.Error
			if errors.As(err, &e) {
				code = e.Code
			}

			// Returns standard JSON Error format for the entire application
			return c.Status(code).JSON(fiber.Map{
				"success": false,
				"message": err.Error(),
				"code": code,
			})
		},
	})

	app.Get("/trigger-error", func(c *fiber.Ctx) error {
		// Returns a specific error 404
		return fiber.NewError(fiber.StatusNotFound, "Resource not found!")
	})

	app.Listen(":3000")
}

package main

import (
	"fmt"
	"log"

	"github.com/gofiber/fiber/v2"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

// Database Model
type Product struct {
	gorm.Model
	Code string `json:"code" gorm:"unique;not null"`
	Price uint `json:"price"`
}

// Global DB Instance (In real projects, use Dependency Injection)
var DB *gorm.DB

func initDatabase() {
	dsn := "host=localhost user=postgres password=root dbname=fiber_db port=5432 sslmode=disable"
	var err error
	DB, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatalf("Failed to connect to database: %v", err)
	}

	fmt.Println("Database Connection Successful!")

	// Auto Migration Model
	DB.AutoMigrate(&Product{})
}

func main() {
	initDatabase()

	app := fiber.New()

	// Add Product Endpoint
	app.Post("/products", func(c *fiber.Ctx) error {
		product := new(Product)
		if err := c.BodyParser(product); err != nil {
			return c.Status(400).SendString(err.Error())
		}

		result := DB.Create(&product)
		if result.Error != nil {
			return c.Status(500).SendString("Failed to save to database")
		}

		return c.Status(201).JSON(product)
	})

	// Endpoint Retrieves Entire Product
	app.Get("/products", func(c *fiber.Ctx) error {
		var products []Product
		DB.Find(&products)
		return c.JSON(products)
	})

	app.Listen(":3000")
}

my-fiber-app/
├── config/ # Environment, Database & App Configuration Settings
│ ├── config.go
│ └── database.go
├── controllers/ # HTTP Handler Layer (Receive Request & Return Response)
│ ├── auth_controller.go
│ └── user_controller.go
├── models/ # Schema Database (GORM Structs)
│ └── user.go
├── repository/ # Data Access Layer (Direct Database Query)
│ └── user_repository.go
├── services/ # Business Logic Layer
│ └── user_service.go
├── middleware/ # Custom Middlewares (JWT, Auth, CORS)
│ └── jwt_middleware.go
├── routes/ # URL Route Mapping
│ └── routes.go
├── .env # Environment Variables
├── go. mod
├── go.sum
└── main.go # Application Main Entrypoint

package main

import (
	"time"

	"github.com/gofiber/fiber/v2"
	"github.com/golang-jwt/jwt/v5"
)

const SecretKey = "SecretKeyVerySafeSuperVery"

// Handler Login to generate JWT Token
func loginHandler(c *fiber.Ctx) error {
	// Example of dummy identity validation...
	username := c.FormValue("username")
	password := c.FormValue("password")

	if username != "admin" || password != "secret" {
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
			"message": "Invalid credentials",
		})
	}

	// Creating Payload Claims
	claims := jwt.MapClaims{
		"username": username,
		"admin": true,
		"exp": time.Now().Add(time.Hour * 72).Unix(), // Token expires in 72 hours
	}

	// Create a Token with the HMAC SHA256 algorithm
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	t, err := token.SignedString([]byte(SecretKey))
	if err != nil {
		return c.SendStatus(fiber.StatusInternalServerError)
	}

	return c.JSON(fiber.Map{
		"token": t,
	})
}

// Custom Middleware to Verify JWT
func JWTMiddleware() fiber.Handler {
	return func(c *fiber.Ctx) error {
		authHeader := c.Get("Authorization")
		if authHeader == "" || len(authHeader) <8 || authHeader[:7] != "Bearer " {
			return c.Status(401).JSON(fiber.Map{"message": "Authorization header not found or incorrect format"})
		}

		tokenString := authHeader[7:]

		// Token Parsing and Validation
		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
			return []byte(SecretKey), nil
		})

		if err != nil || !token.Valid {
			return c.Status(401).JSON(fiber.Map{"message": "Token is invalid or has expired"})
		}

		// Saves JWT claims data into Context Fiber for use in the next handler
		claims := token.Claims.(jwt.MapClaims)
		c.Locals("user_data", claims)

		return c.Next()
	}
}