Pada artikel instalasi perlengkapan coding golang, penulis sudah membahas mengenai bagaiman cara instalasi golang. Pada artikel ini, penulis akan membahas salah satu framework yang lumayan banyak digunakan yaitu gofiber atau biasa juga disebut fiber dan penulis akan memberikan contoh bagaimana penggunaan gofiber.
Apa itu GoFiber ?
GoFiber merupakan salah satu framework Go-Lang yang dibangun dengan Fasthttp dimana Fasthttp ini merupakan salah satu library atau package yang dibuat untuk keperluan server side.
GoFiber sendiri dikembangan berdasarkan inspirasi dari framework express js. Jadi bagi teman - teman yang pernah melakukan development dengan express js maka tidak akan asing lagi dengan framework gofiber ini.
Membuat Project
Untuk membuat project, silahkan buat sebuah folder yaitu belajar-gofiber lalu jalankan perintah
go mod init github.com/RizkiMufrizal/belajar-gofiber
Teman - teman bisa sesuaikan dengan nama project yang telah dibuat. Pada artikel ini, kita akan membuat restful api CRUD sederhana, pasti nya menggunakan ORM dari GORM. Untuk melakukan instalasi gofiber silahkan jalankan perintah berikut.
go get github.com/gofiber/fiber/v2
Lalu untuk gorm, silahkan jalankan perintah berikut.
Untuk driver mysql, silahkan jalankan perintah berikut.
go get -u gorm.io/driver/mysql
Lalu untuk konfigurasi .env, silahkan jalankan perintah berikut.
go get -u github.com/joho/godotenv
Standard Struktur Folder
Sebenarnya di dalam gofiber ini tidak ada suatu standard struktur folder melainkan dari masing - masing developer dapat menentukan standard nya.
➜ belajar-gofiber git:(master) ✗ tree -c
.
├── .env
├── .gitignore
├── Dockerfile
├── docker-compose.yml
├── README.md
├── go.mod
├── go.sum
├── main.go
├── configuration
├── controller
├── entity
├── middleware
├── model
├── exception
├── repository
│ └── impl
└── service
└── impl
- .env : digunakan untuk menyimpan parameter seperti koneksi ke database, pooling dan sebagainya.
- .gitignore : digunakan untuk list file atau folder yang akan di ignore atau tidak ikut commit.
- Dockerfile : digunakan untuk konfigurasi docker.
- docker-compose.yml : digunakan untuk konfigurasi docker compose, biasa nya digunakan untuk menjalankan aplikasi pihak ketiga yang dibutuhkan oleh aplikasi kita seperti database, message broker dan lain sebagai nya.
- README.md : digunakan untuk informasi dari sebuah project.
- go.mod dan go.sum : adalah go module sebagai dependency management pada golang.
- main.go : digunakan untuk main file yang akan di jalankan di golang.
- configuration : digunakan untuk menyimpan konfigurasi seperti konfigurasi ke database, logger dan lain sebagain nya.
- controller : digunakan untuk menghadle request yang masuk ke aplikasi.
- entity : digunakan untuk mendefinisikan entity yang merepresentasikan ke table pada database.
- middleware : digunakan untuk processing yang berkaitan pada pre request maupun pre response. Biasa nya digunakan untuk pengecekan security, logging dan sebagainya.
- model : digunakan sebagai DTO (data transfer object), dimana biasa nya pada package ini terdapat object - object yang dibutuhkan untuk request dan response.
- exception : digunakan untuk kumpulan exception.
- repository : digunakan untuk akses ke database (repository pattern).
- repository/impl : digunakan untuk akses ke database (implementasi dari repository)
- service : digunakan untuk bisnis logic
- service/impl : digunakan untuk bisnis logic (implementasi dari service)
Membuat Konfigurasi
Untuk proses membuat konfigurasi ada beberapa tahapan yaitu
Membuat Konfigurasi .env
Pada file .env terdapat beberapa konfigurasi yaitu server port, database, database pooling dan user basic auth. Silahkan buka file .env lalu tambahkan code berikut
SERVER.PORT=0.0.0.0:9999
#Database Config
DATASOURCE_USERNAME=root
DATASOURCE_PASSWORD=root
DATASOURCE_HOST=localhost
DATASOURCE_PORT=3306
DATASOURCE_DB_NAME=belajar_gofiber
#Pool Config
DATASOURCE_POOL_MAX_CONN=10
DATASOURCE_POOL_IDLE_CONN=5
DATASOURCE_POOL_LIFE_TIME=30000
#User Basic Auth
username=admin
password=admin
Membuat Konfigurasi Pada Package configuration dan exception
Pada package exception, silahkan buat file error.go lalu masukkan code berikut
package exception
func PanicLogging(err interface{}) {
if err != nil {
panic(err)
}
}
Code diatas berfungsi sebagai global error, jadi kita tidak perlu secara manual membuat panic, cukup panggil function tersebut.
Pada package configuration, silahkan buat 2 file yaitu config.go dan database.go. Silahkan buka file config.go lalu masukan konfigurasi seperti berikut.
package configuration
import (
"github.com/RizkiMufrizal/belajar-gofiber/exception"
"github.com/joho/godotenv"
"os"
)
type Config interface {
Get(key string) string
}
type configImpl struct {
}
func (config *configImpl) Get(key string) string {
return os.Getenv(key)
}
func New(filenames ...string) Config {
err := godotenv.Load(filenames...)
exception.PanicLogging(err)
return &configImpl{}
}
Code diatas berfungsi untuk memanggil file .env, sehingga kita bisa menggunakan parameter - parameter yang terdapat pada file .env.
Lalu pada file database.go silahkan isi code berikut.
package configuration
import (
"github.com/RizkiMufrizal/belajar-gofiber/exception"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/logger"
"log"
"math/rand"
"os"
"strconv"
"time"
)
func NewDatabase(config Config) *gorm.DB {
username := config.Get("DATASOURCE_USERNAME")
password := config.Get("DATASOURCE_PASSWORD")
host := config.Get("DATASOURCE_HOST")
port := config.Get("DATASOURCE_PORT")
dbName := config.Get("DATASOURCE_DB_NAME")
maxPoolOpen, err := strconv.Atoi(config.Get("DATASOURCE_POOL_MAX_CONN"))
maxPoolIdle, err := strconv.Atoi(config.Get("DATASOURCE_POOL_IDLE_CONN"))
maxPollLifeTime, err := strconv.Atoi(config.Get("DATASOURCE_POOL_LIFE_TIME"))
exception.PanicLogging(err)
loggerDb := logger.New(
log.New(os.Stdout, "\r\n", log.LstdFlags),
logger.Config{
SlowThreshold: time.Second,
LogLevel: logger.Info,
IgnoreRecordNotFoundError: true,
Colorful: true,
},
)
db, err := gorm.Open(mysql.Open(username+":"+password+"@tcp("+host+":"+port+")/"+dbName+"?parseTime=true"), &gorm.Config{
Logger: loggerDb,
})
exception.PanicLogging(err)
sqlDB, err := db.DB()
exception.PanicLogging(err)
sqlDB.SetMaxOpenConns(maxPoolOpen)
sqlDB.SetMaxIdleConns(maxPoolIdle)
sqlDB.SetConnMaxLifetime(time.Duration(rand.Int31n(int32(maxPollLifeTime))) * time.Millisecond)
//autoMigrate
return db
}
Pada bagian autoMigrate, nanti nya akan kita gunakan agar table nya otomatis di migrate sehingga kita tidak perlu create secara manual.
Membuat Entity dan Model
Pada bagian sebelum nya sudah dijelaskan bahwa entity akan berkaitan langsung dengan database sedangkan model akan berkaitan dengan DTO (data transfer object).
Membuat Entity
Pada artikel ini, kita hanya membuat 1 table saja yaitu table product, silahkan buat sebuah file product.go di dalam folder entity lalu masukkan code berikut.
package entity
type Product struct {
Id int32 `gorm:"primaryKey;auto_increment;column:product_id"`
Name string `gorm:"index;column:name;type:varchar(100)"`
Price int64 `gorm:"column:price"`
Quantity int32 `gorm:"column:quantity"`
}
func (Product) TableName() string {
return "tb_product"
}
Lalu silahkan buka file database.go kembali, pada bagian //autoMigrate silahkan tambahkan code berikut
//autoMigrate
err = db.AutoMigrate(&entity.Product{})
exception.PanicLogging(err)
Membuat Model
Pada package model, silahkan buat 1 buat file yaitu product_model.go lalu masukkan code berikut
package model
type ProductModel struct {
Id int32 `json:"id"`
Name string `json:"name"`
Price int64 `json:"price"`
Quantity int32 `json:"quantity"`
}
type ProductCreateOrUpdateModel struct {
Name string `json:"name" validate:"required"`
Price int64 `json:"price" validate:"required"`
Quantity int32 `json:"quantity" validate:"required"`
}
Dapat dilihat pada product model, kita mempunya 2 struct, dimana struct ProductModel digunakan untuk menampilkan product, sedangkan struct ProductCreateOrUpdateModel digunakan hanya untuk create dan update product saja. Lalu silkahkan buat sebuah file general_response.go untuk standarisasi response. lalu masukkan code berikut.
package model
type GeneralResponse struct {
Code int `json:"code"`
Message string `json:"message"`
Data interface{} `json:"data"`
}
Membuat Repository
Repository disini bertugas untuk mengakses ke database. Pada repository ini, kita akan membuat sebuah interface yang berfungsi sebagai mendeklarasikan function - function yang akan kita gunakan. Lalu interface ini nanti nya akan di implementasikan. Silahkan buat file product_repository.go pada package repository, lalu masukkan code berikut.
package repository
import (
"context"
"github.com/RizkiMufrizal/belajar-gofiber/entity"
)
type ProductRepository interface {
Insert(ctx context.Context, product entity.Product) entity.Product
Update(ctx context.Context, product entity.Product) entity.Product
Delete(ctx context.Context, product entity.Product)
FindById(ctx context.Context, id int32) (entity.Product, error)
FindAl(ctx context.Context) []entity.Product
}
Lalu pada package repository/impl, silahkan buat file product_repository_impl.go lalu masukkan code berikut
package impl
import (
"context"
"errors"
"github.com/RizkiMufrizal/belajar-gofiber/entity"
"github.com/RizkiMufrizal/belajar-gofiber/exception"
"github.com/RizkiMufrizal/belajar-gofiber/repository"
"gorm.io/gorm"
)
func NewProductRepositoryImpl(DB *gorm.DB) repository.ProductRepository {
return &productRepositoryImpl{DB: DB}
}
type productRepositoryImpl struct {
*gorm.DB
}
func (repository *productRepositoryImpl) Insert(ctx context.Context, product entity.Product) entity.Product {
err := repository.DB.WithContext(ctx).Create(&product).Error
exception.PanicLogging(err)
return product
}
func (repository *productRepositoryImpl) Update(ctx context.Context, product entity.Product) entity.Product {
err := repository.DB.WithContext(ctx).Where("product_id = ?", product.Id).Updates(&product).Error
exception.PanicLogging(err)
return product
}
func (repository *productRepositoryImpl) Delete(ctx context.Context, product entity.Product) {
err := repository.DB.WithContext(ctx).Delete(&product).Error
exception.PanicLogging(err)
}
func (repository *productRepositoryImpl) FindById(ctx context.Context, id int32) (entity.Product, error) {
var product entity.Product
result := repository.DB.WithContext(ctx).Unscoped().Where("product_id = ?", id).First(&product)
if result.RowsAffected == 0 {
return entity.Product{}, errors.New("product Not Found")
}
return product, nil
}
func (repository *productRepositoryImpl) FindAl(ctx context.Context) []entity.Product {
var products []entity.Product
repository.DB.WithContext(ctx).Find(&products)
return products
}
Membuat Service
Pada bagian package service, code yang akan kita tulis lebih ke fungsi logic bisnis yang diperlukan. Silahkan buat file product_service.go pada package service lalu masukkan code berikut.
package service
import (
"context"
"github.com/RizkiMufrizal/belajar-gofiber/model"
)
type ProductService interface {
Create(ctx context.Context, model model.ProductCreateOrUpdateModel) model.ProductCreateOrUpdateModel
Update(ctx context.Context, productModel model.ProductCreateOrUpdateModel, id int32) model.ProductCreateOrUpdateModel
Delete(ctx context.Context, id int32)
FindById(ctx context.Context, id int32) model.ProductModel
FindAll(ctx context.Context) []model.ProductModel
}
Bisa dilihat dari code diatas, pada bagian service, kita akan menggunakan model, bukan entity untuk memunculkan atau menerima data product. Lalu buat sebuah file product_service_impl.go pada package service/impl, lalu masukkan code berikut
package impl
import (
"context"
"github.com/RizkiMufrizal/belajar-gofiber/entity"
"github.com/RizkiMufrizal/belajar-gofiber/exception"
"github.com/RizkiMufrizal/belajar-gofiber/model"
"github.com/RizkiMufrizal/belajar-gofiber/repository"
"github.com/RizkiMufrizal/belajar-gofiber/service"
)
func NewProductServiceImpl(productRepository *repository.ProductRepository) service.ProductService {
return &productServiceImpl{ProductRepository: *productRepository}
}
type productServiceImpl struct {
repository.ProductRepository
}
func (service *productServiceImpl) Create(ctx context.Context, productModel model.ProductCreateOrUpdateModel) model.ProductCreateOrUpdateModel {
product := entity.Product{
Name: productModel.Name,
Price: productModel.Price,
Quantity: productModel.Quantity,
}
service.ProductRepository.Insert(ctx, product)
return productModel
}
func (service *productServiceImpl) Update(ctx context.Context, productModel model.ProductCreateOrUpdateModel, id int32) model.ProductCreateOrUpdateModel {
product := entity.Product{
Id: id,
Name: productModel.Name,
Price: productModel.Price,
Quantity: productModel.Quantity,
}
service.ProductRepository.Update(ctx, product)
return productModel
}
func (service *productServiceImpl) Delete(ctx context.Context, id int32) {
product, err := service.ProductRepository.FindById(ctx, id)
if err != nil {
panic(exception.NotFoundError{
Message: err.Error(),
})
}
service.ProductRepository.Delete(ctx, product)
}
func (service *productServiceImpl) FindById(ctx context.Context, id int32) model.ProductModel {
product, err := service.ProductRepository.FindById(ctx, id)
exception.PanicLogging(err)
return model.ProductModel{
Id: product.Id,
Name: product.Name,
Price: product.Price,
Quantity: product.Quantity,
}
}
func (service *productServiceImpl) FindAll(ctx context.Context) (responses []model.ProductModel) {
products := service.ProductRepository.FindAl(ctx)
for _, product := range products {
responses = append(responses, model.ProductModel{
Id: product.Id,
Name: product.Name,
Price: product.Price,
Quantity: product.Quantity,
})
}
if len(products) == 0 {
return []model.ProductModel{}
}
return responses
}
Pada bagian exception.NotFoundError pasti error karena kita belum membuat error handling tersebut, silahkan buat file not_found_error.go pada package exception lalu masukkan code berikut.
package exception
type NotFoundError struct {
Message string
}
func (notFoundError NotFoundError) Error() string {
return notFoundError.Message
}
Membuat Middleware
Sebelum lanjut ke controller, kita akan membuat middleware pada artikel ini. Middleware yang dibuat pada artikel disini hanya sebatas security dengan menggunakan basic authentication dan credentials nya sementara akan di hardcode di file .env. Silahkan buat file basic_auth.go di dalam package middleware lalu masukkan code berikut.
package middleware
import (
"encoding/base64"
"github.com/RizkiMufrizal/belajar-gofiber/configuration"
"github.com/RizkiMufrizal/belajar-gofiber/exception"
"github.com/RizkiMufrizal/belajar-gofiber/model"
"github.com/gofiber/fiber/v2"
"strings"
)
func BasicAuth(config configuration.Config) fiber.Handler {
return func(ctx *fiber.Ctx) error {
username := config.Get("USERNAME")
password := config.Get("PASSWORD")
basicAuth := ctx.Get("Authorization")
if basicAuth == "" {
return ctx.
Status(fiber.StatusBadRequest).
JSON(model.GeneralResponse{
Code: 404,
Message: "Bad Request",
Data: "Header Not Found",
})
}
basicAuthDecode, err := base64.StdEncoding.DecodeString(strings.Split(basicAuth, " ")[1])
exception.PanicLogging(err)
basicAuthDecodeString := string(basicAuthDecode)
basicAuthUsername := strings.Split(basicAuthDecodeString, ":")[0]
basicAuthPassword := strings.Split(basicAuthDecodeString, ":")[1]
if username != basicAuthUsername && password != basicAuthPassword {
return ctx.
Status(fiber.StatusUnauthorized).
JSON(model.GeneralResponse{
Code: 401,
Message: "Unauthorized",
Data: "Invalid Credentials",
})
}
return ctx.Next()
}
}
Membuat Controller
Semua yang terdapat di dalam controller akan menghadle request yang datang dari user / client. Silahkan buat file product_controller.go pada package controller, lalu masukkan code berikut.
package controller
import (
"github.com/RizkiMufrizal/belajar-gofiber/configuration"
"github.com/RizkiMufrizal/belajar-gofiber/exception"
"github.com/RizkiMufrizal/belajar-gofiber/middleware"
"github.com/RizkiMufrizal/belajar-gofiber/model"
"github.com/RizkiMufrizal/belajar-gofiber/service"
"github.com/gofiber/fiber/v2"
)
type ProductController struct {
service.ProductService
configuration.Config
}
func NewProductController(productService *service.ProductService, config configuration.Config) *ProductController {
return &ProductController{ProductService: *productService, Config: config}
}
func (controller ProductController) Route(app *fiber.App) {
app.Post("/v1/api/product", middleware.BasicAuth(controller.Config), controller.Create)
app.Put("/v1/api/product/:id", middleware.BasicAuth(controller.Config), controller.Update)
app.Delete("/v1/api/product/:id", middleware.BasicAuth(controller.Config), controller.Delete)
app.Get("/v1/api/product/:id", middleware.BasicAuth(controller.Config), controller.FindById)
app.Get("/v1/api/product", middleware.BasicAuth(controller.Config), controller.FindAll)
}
func (controller ProductController) Create(c *fiber.Ctx) error {
var request model.ProductCreateOrUpdateModel
err := c.BodyParser(&request)
exception.PanicLogging(err)
response := controller.ProductService.Create(c.Context(), request)
return c.Status(fiber.StatusCreated).JSON(model.GeneralResponse{
Code: 200,
Message: "Success",
Data: response,
})
}
func (controller ProductController) Update(c *fiber.Ctx) error {
var request model.ProductCreateOrUpdateModel
id, err := c.ParamsInt("id")
err = c.BodyParser(&request)
exception.PanicLogging(err)
response := controller.ProductService.Update(c.Context(), request, int32(id))
return c.Status(fiber.StatusOK).JSON(model.GeneralResponse{
Code: 200,
Message: "Success",
Data: response,
})
}
func (controller ProductController) Delete(c *fiber.Ctx) error {
id, err := c.ParamsInt("id")
exception.PanicLogging(err)
controller.ProductService.Delete(c.Context(), int32(id))
return c.Status(fiber.StatusOK).JSON(model.GeneralResponse{
Code: 200,
Message: "Success",
})
}
func (controller ProductController) FindById(c *fiber.Ctx) error {
id, err := c.ParamsInt("id")
exception.PanicLogging(err)
result := controller.ProductService.FindById(c.Context(), int32(id))
return c.Status(fiber.StatusOK).JSON(model.GeneralResponse{
Code: 200,
Message: "Success",
Data: result,
})
}
func (controller ProductController) FindAll(c *fiber.Ctx) error {
result := controller.ProductService.FindAll(c.Context())
return c.Status(fiber.StatusOK).JSON(model.GeneralResponse{
Code: 200,
Message: "Success",
Data: result,
})
}
Membuat Exception Handler
Yang tidak kalah penting nya adalah membuat exception handler, Dimana exception ini agar aplikasi tidak berhenti dan dapat mengeluarkan error secara proper. Silahkan buat file error_handler.go pada package exception lalu isi code berikut
package exception
import (
"github.com/RizkiMufrizal/belajar-gofiber/model"
"github.com/gofiber/fiber/v2"
)
func ErrorHandler(ctx *fiber.Ctx, err error) error {
_, notFoundError := err.(NotFoundError)
if notFoundError {
return ctx.Status(fiber.StatusNotFound).JSON(model.GeneralResponse{
Code: 404,
Message: "Not Found",
Data: err.Error(),
})
}
return ctx.Status(fiber.StatusInternalServerError).JSON(model.GeneralResponse{
Code: 500,
Message: "General Error",
Data: err.Error(),
})
}
Lalu buat sebuah file fiber.go di dalam configuration lalu isi code berikut
package configuration
import (
"github.com/RizkiMufrizal/belajar-gofiber/exception"
"github.com/gofiber/fiber/v2"
)
func NewFiberConfiguration() fiber.Config {
return fiber.Config{
ErrorHandler: exception.ErrorHandler,
}
}
Code pada fiber.go nanti nya akan dipanggil senagai error handling, sehingga diharapkan aplikasi dapat mengeluarkan response code yang proper.
Membuat Main
Silahkan buat file main.go di root folder, file ini bertugas sebagai main object yang akan dijalankan. Silahkan masukkan code nya seperti berikut.
package main
import (
"github.com/RizkiMufrizal/belajar-gofiber/configuration"
"github.com/RizkiMufrizal/belajar-gofiber/controller"
"github.com/RizkiMufrizal/belajar-gofiber/exception"
repository "github.com/RizkiMufrizal/belajar-gofiber/repository/impl"
service "github.com/RizkiMufrizal/belajar-gofiber/service/impl"
"github.com/gofiber/fiber/v2"
"github.com/gofiber/fiber/v2/middleware/cors"
"github.com/gofiber/fiber/v2/middleware/recover"
)
func main() {
//setup configuration
config := configuration.New()
database := configuration.NewDatabase(config)
//repository
productRepository := repository.NewProductRepositoryImpl(database)
//service
productService := service.NewProductServiceImpl(&productRepository)
//controller
productController := controller.NewProductController(&productService, config)
//setup fiber
app := fiber.New(configuration.NewFiberConfiguration())
app.Use(recover.New())
app.Use(cors.New())
//routing
productController.Route(app)
//start app
err := app.Listen(config.Get("SERVER.PORT"))
exception.PanicLogging(err)
}
Membuat Dockerfile dan Docker Compose
Pada tahap terakhir, kita perlu membuat dockerfile jika nanti suatu saat perlu di deploy ke kubernetes atau openshift. Silahkan buat file Dockerfile di root folder lalu masukkan code berikut.
# Get Go image from DockerHub.
FROM golang:1.19.5 AS api
# Set working directory.
WORKDIR /compiler
# Copy dependency locks so we can cache.
COPY go.mod go.sum ./
# Get all of our dependencies.
RUN go mod download
# Copy all of our remaining application.
COPY . .
# Build our application.
RUN CGO_ENABLED=0 GOOS=linux go build -o server ./main.go
# Use 'scratch' image for super-mini build.
FROM scratch AS prod
# Set working directory for this stage.
WORKDIR /app
# Copy our compiled executable from the last stage.
COPY --from=api /compiler/server .
# Run application and expose port 9999.
EXPOSE 9999
CMD ["./server"]
Untuk proses build docker image, teman - teman bisa lihat cara nya di belajar docker.
Sedangkan untuk docker compose, silahkan buat file docker-compose.yml pada root folder lalu masukkan code berikut
version: '3.1'
services:
db:
image: mysql
command: --default-authentication-plugin=mysql_native_password
restart: always
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_DATABASE: belajar_gofiber
ports:
- "3306:3306"
adminer:
image: adminer
restart: always
ports:
- "8080:8080"
Lalu jalankan docker compose dengan perintah
Menjalankan, Build dan Test Aplikasi
Setelah selesai membuat code nya, tahapan selanjut nya adalah menjalankan aplikasi nya. Cara menjalankan silahkan gunakan perintah berikut.
Jika sudah muncul output berikut
┌───────────────────────────────────────────────────┐
│ Fiber v2.41.0 │
│ http://127.0.0.1:9999 │
│ (bound on host 0.0.0.0 and port 9999) │
│ │
│ Handlers ............ 16 Processes ........... 1 │
│ Prefork ....... Disabled PID ............. 32394 │
└───────────────────────────────────────────────────┘
Berarti aplikasi gofiber nya sudah berjalan sebagai mesti nya. Untuk melakukan build, teman - teman cukup menjalankan perintah berikut.
Untuk melakukan test aplikasi, teman - teman bisa menggunakan postman atau perintah curl. Contoh nya disini penulis menggunakan perintah curl seperti berikut
curl --location --request POST 'http://localhost:9999/v1/api/product' \
--header 'Authorization: Basic YWRtaW46YWRtaW4=' \
--header 'Content-Type: application/json' \
--data-raw '{
"name": "product 1",
"price": 1000,
"quantity": 5
}'
dan hasil nya
{"code":200,"message":"Success","data":{"name":"product 1","price":1000,"quantity":5}}
Atau jika teman - teman ingin menampilkan semua nya bisa menggunakan perintah berikut.
curl --location --request GET 'http://localhost:9999/v1/api/product' \
--header 'Authorization: Basic YWRtaW46YWRtaW4=' \
--header 'Content-Type: application/json'
dan berikut hasil nya
{"code":200,"message":"Success","data":[{"id":1,"name":"product 1","price":1000,"quantity":5}]}
Akhirnya selesai juga artikel mengenai belajar go fiber :). Untuk source code diatas dapat anda akses di belajar gofiber atau jika teman - teman ingin yang lebih advance bisa lihat source nya di gofiber clean architecture). Sekian artikel mengenai Belajar gofiber, jika ada saran dan komentar silahkan isi dibawah dan terima kasih :).
