Go Fiber: Web Framework yang Super Cepat untuk API

Kenapa Fiber?

Saat pertama kali mencoba Go Fiber, saya langsung kagum dengan kecepatannya. Fiber dibangun di atas fasthttp, bukan net/http standar, yang membuatnya 2-10x lebih cepat dari framework Go lainnya untuk HTTP handling.

Bagi saya, Fiber adalah sweet spot antara kecepatan dan developer experience. Syntax-nya mirip Express.js atau FastAPI, jadi kalau Anda pernah pakai framework JS/Python, akan familiar.

Setup Project dengan Fiber

package main

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

func main() {
    app := fiber.New(fiber.Config{
        AppName:      "My SaaS API",
        ServerHeader: "Fiber",
        Prefork:      true,
    })

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

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

Routing yang Powerful

Fiber support semua pattern routing yang Anda butuhkan:

// Path parameters
app.Get("/users/:id", getUser)

// Wildcard
app.Get("/files/*", serveFile)

// Group routes untuk versioning API
api := app.Group("/api/v1")
api.Get("/projects", listProjects)
api.Post("/projects", createProject)
api.Get("/projects/:id", getProject)
api.Put("/projects/:id", updateProject)
api.Delete("/projects/:id", deleteProject)

// Route group dengan middleware
auth := api.Group("/auth", AuthMiddleware)
auth.Get("/profile", getProfile)
auth.Put("/profile", updateProfile)

Middleware yang Berguna

Salah satu kekuatan Fiber adalah middleware system-nya:

// CORS middleware
app.Use(cors.New(cors.Config{
    AllowOrigins: "https://myapp.com",
    AllowHeaders: "Origin, Content-Type, Accept",
}))

// Rate limiting
app.Use(limiter.New(limiter.Config{
    Max:        100,
    Expiration: 1 * time.Minute,
}))

// Custom logger
app.Use(logger.New(logger.Config{
    Format: "${time} | ${status} | ${method} ${path} | ${latency}\n",
}))

Benchmark: Fiber vs Chi vs Gin

Dari benchmark yang saya lakukan untuk API REST dengan JSON response:

• Fiber: ~180,000 req/s
• Gin: ~120,000 req/s
• Chi: ~95,000 req/s

Nomor ini bisa bervariasi tergantung workload, tapi Fiber consistently di atas untuk simple HTTP handlers.

Kapan Tidak Pakai Fiber?

Jujur, Fiber tidak cocok untuk semua use case. Kalau Anda butuh HTTP/2 server push atau native net/http compatibility, pertimbangkan Gin atau Chi. Tapi untuk REST API SaaS dengan performa tinggi, Fiber adalah pilihan yang solid.

Error Handling di Fiber

Error handling yang konsisten adalah kunci untuk maintainable API. Saya biasanya buat custom error handler:

// Custom error handler
type APIError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

func ErrorHandler(c *fiber.Ctx, err error) error {
    code := fiber.StatusInternalServerError
    message := "Internal Server Error"

    if e, ok := err.(*APIError); ok {
        code = e.Code
        message = e.Message
    }

    return c.Status(code).JSON(fiber.Map{"error": message})
}

func main() {
    app := fiber.New(fiber.Config{
        ErrorHandler: ErrorHandler,
    })
}

Dengan approach ini, semua error di API Anda punya format yang konsisten. Frontend tinggal handle satu format response untuk semua error case. Clean dan predictable.

Request Validation dengan Go Playground Validator

Validasi input sangat penting untuk API yang robust. Fiber integrate dengan Go Playground Validator secara seamless:

type CreateUserRequest struct {
    Name  string `json:"name" validate:"required,min=2,max=100"`
    Email string `json:"email" validate:"required,email"`
    Age   int    `json:"age" validate:"gte=13,lte=120"`
}

func CreateUser(c *fiber.Ctx) error {
    req := new(CreateUserRequest)
    if err := c.BodyParser(req); err != nil {
        return c.Status(400).JSON(fiber.Map{"error": "invalid request body"})
    }
    if err := validator.Struct(req); err != nil {
        return c.Status(400).JSON(fiber.Map{"error": err.Error()})
    }
    // proceed with valid data
}