Memahami Golang Fiber: Dari Konsep Dasar hingga Arsitektur Aplikasi

Rahasia di Balik Performa Fiber: Arsitektur Fasthttp

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

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

package main

import (
	"log"

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

func main() {
	// 1. Membuat instance aplikasi Fiber baru
	app := fiber.New(fiber.Config{
		Prefork:       false, // Ubah ke true jika ingin memanfaatkan arsitektur multi-core secara maksimal
		CaseSensitive: true,  // Membedakan URL /user dan /User
		StrictRouting: true,  // Membedakan URL /user/ dan /user
		AppName:       "My Fiber Application v1.0",
	})

	// 2. Definisi Route Dasar
	app.Get("/", func(c *fiber.Ctx) error {
		return c.SendString("Selamat Datang di Dunia Golang Fiber!")
	})

	// 3. Menjalankan Server pada 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("Menampilkan data user dengan ID: " + userId)
})

// Parameter Opsional (tanda tanya ?)
// Endpoint: GET /flights/JAKARTA-BALI atau /flights/
app.Get("/flights/:route?", func(c *fiber.Ctx) error {
	if c.Params("route") != "" {
		return c.SendString("Rute penerbangan: " + c.Params("route"))
	}
	return c.SendString("Menampilkan seluruh rute penerbangan")
})

// Wildcard Parameter (tanda bintang *)
// Endpoint: GET /files/documents/pdf/report.pdf
app.Get("/files/*", func(c *fiber.Ctx) error {
	filePath := c.Params("*")
	return c.SendString("Membuka file di jalur: " + filePath)
})

app.Get("/search", func(c *fiber.Ctx) error {
	keyword := c.Query("keyword", "default_keyword") // "default_keyword" jika tidak diisi
	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 untuk Modul Produk
	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 {
	// Instansiasi struct
	req := new(CreateUserRequest)

	// Parsing body ke struct
	if err := c.BodyParser(req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": true,
			"message": "Format request body tidak valid",
		})
	}

	// Proses logika bisnis (misal simpan ke database)...

	return c.Status(fiber.StatusCreated).JSON(fiber.Map{
		"error": false,
		"message": "User berhasil dibuat",
		"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())
	}

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

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

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: Mencatat log setiap request di terminal
	app.Use(logger.New(logger.Config{
		Format: "[${time}] ${status} - ${latency} ${method} ${path}\n",
	}))

	// 2. Recover: Mencegah server crash jika terjadi panic di dalam kode
	app.Use(recover.New())

	// 3. CORS: Mengizinkan akses dari domain Frontend tertentu
	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 untuk mengecek Header Api-Key
func ApiKeyMiddleware() fiber.Handler {
	return func(c *fiber.Ctx) error {
		apiKey := c.Get("X-API-KEY")

		if apiKey != "RAHASIA-SUPER-123" {
			return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
				"error": "Akses Ditolak: API Key tidak valid",
			})
		}

		// Melanjutkan ke Middleware atau Handler berikutnya
		return c.Next()
	}
}

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

	// Menerapkan middleware khusus pada rute terproteksi
	api := app.Group("/api", ApiKeyMiddleware())

	api.Get("/dashboard", func(c *fiber.Ctx) error {
		return c.SendString("Selamat, Anda berhasil mengakses dashboard terproteksi!")
	})

	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 adalah 500 (Internal Server Error)
			code := fiber.StatusInternalServerError

			// Cek apakah error merupakan tipe *fiber.Error
			var e *fiber.Error
			if errors.As(err, &e) {
				code = e.Code
			}

			// Mengembalikan format JSON Error standar untuk seluruh aplikasi
			return c.Status(code).JSON(fiber.Map{
				"success": false,
				"message": err.Error(),
				"code":    code,
			})
		},
	})

	app.Get("/trigger-error", func(c *fiber.Ctx) error {
		// Mengembalikan error spesifik 404
		return fiber.NewError(fiber.StatusNotFound, "Sumber daya tidak ditemukan!")
	})

	app.Listen(":3000")
}

package main

import (
	"fmt"
	"log"

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

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

// Global DB Instance (Dalam proyek nyata, gunakan 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("Gagal terhubung ke database: %v", err)
	}

	fmt.Println("Koneksi Database Berhasil!")

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

func main() {
	initDatabase()

	app := fiber.New()

	// Endpoint Menambahkan Produk
	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("Gagal menyimpan ke database")
		}

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

	// Endpoint Mengambil Seluruh Produk
	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/             # Pengaturan Environment, Database, & Konfigurasi App
│   ├── config.go
│   └── database.go
├── controllers/        # Layer Handler HTTP (Menerima Request & Mengembalikan Response)
│   ├── auth_controller.go
│   └── user_controller.go
├── models/             # Schema Database (GORM Structs)
│   └── user.go
├── repository/         # Layer Akses Data (Kueri Database Direct)
│   └── user_repository.go
├── services/           # Layer Logika Bisnis (Business Logic Layer)
│   └── user_service.go
├── middleware/         # Custom Middlewares (JWT, Auth, CORS)
│   └── jwt_middleware.go
├── routes/             # Pemetaan Rute URL
│   └── routes.go
├── .env                # Variables Lingkungan
├── go.mod
├── go.sum
└── main.go             # Entrypoint Utama Aplikasi

package main

import (
	"time"

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

const SecretKey = "KunciRahasiaSangatAmanSuperSekali"

// Handler Login untuk menghasilkan Token JWT
func loginHandler(c *fiber.Ctx) error {
	// Contoh validasi identitas dummy...
	username := c.FormValue("username")
	password := c.FormValue("password")

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

	// Membuat Payload Claims
	claims := jwt.MapClaims{
		"username": username,
		"admin":    true,
		"exp":      time.Now().Add(time.Hour * 72).Unix(), // Token kadaluarsa dalam 72 jam
	}

	// Membuat Token dengan algoritma HMAC SHA256
	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,
	})
}

// Middleware Kustom untuk Memverifikasi 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": "Header Authorization tidak ditemukan atau format salah"})
		}

		tokenString := authHeader[7:]

		// Parsing dan Validasi Token
		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 tidak valid atau telah kadaluarsa"})
		}

		// Menyimpan data claims JWT ke dalam Context Fiber untuk dipakai di handler berikutnya
		claims := token.Claims.(jwt.MapClaims)
		c.Locals("user_data", claims)

		return c.Next()
	}
}