DEV Community: Perm Chao

Implement semaphore in golang by buffered channel

Perm Chao — Tue, 10 Jun 2025 15:06:34 +0000

Getting started

1) make buffered channel

sem := make(chan int, 10)

2) in synchronous process, send some variable to buffered channel (this step called acquire)

sem <- i

3) in asynchronous process, release variable from buffered channel (this step called release)

<- sem

Result from log

start   process [9]
start   process [0]
start   process [7]
start   process [6]
start   process [3]
start   process [2]
start   process [4]
start   process [8]
start   process [1]
start   process [5] <- 10 processes start concurrency
end     process [0]      0.0001 seconds
start   process [10] <- process 10 start after process 0 end
end     process [2]      4.0014 seconds
end     process [1]      4.0012 seconds
start   process [12]
start   process [11] <- process 11, 12 start after process 1, 2 end
end     process [3]      5.0011 seconds
start   process [13]
end     process [4]      0.0001 seconds
start   process [14]
end     process [5]      6.0014 seconds
start   process [15]
end     process [6]      1.0011 seconds
start   process [16]
end     process [7]      8.0013 seconds
start   process [17]
...

Remark

Standard package
golang.org/x/sync/semaphore

Code

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const (
    MAX_CONCURRENT     = 10   // Allow max concurrent
    TOTAL_PROCESSES    = 1000 // Total loop count
    MAX_RANDOM_SECONDS = 20
)

func main() {
    sem := make(chan int, MAX_CONCURRENT)
    for i := range TOTAL_PROCESSES {
        sem <- i // *** send i to buffered channel. If channel sem full, it blocked for loop.
        go func(i int) {
            start := time.Now()
            fmt.Printf("start\tprocess\t[%d]\n", i)
            defer func() {
                // <- sem will release a value, so sem channel will available for next value
                fmt.Printf("end\tprocess\t[%d]\t %.4f seconds\n", <-sem, time.Since(start).Seconds())
            }()
            iv := rand.Intn(MAX_RANDOM_SECONDS) * int(time.Second)
            time.Sleep(time.Duration(iv))
        }(i)
    }
}

Produce and consume Kafka message with samara and golang

Perm Chao — Sat, 07 Jun 2025 04:52:53 +0000

Declare producer
Produce message
Declare consumer
Consume each partition

Port and Adapter in Go with Uber FX

Perm Chao — Thu, 08 May 2025 10:11:27 +0000

Case

Sending email

Folder Structure

cmd/sender/main.go
internal/services/sender/sender.go
adapters/gmail/gmail.go
adapters/hotmail/hotmail.go

Steps

Create port

File: internal/services/sender/sender.go

IEmailPort will be interface for adapter

Create core business

File: internal/services/sender/sender.go

IEmailService will be interface for UberFX
EmailService will be struct of service with attribute emailPort(will be injected by UberFX)
NewEmailService is constructor

Create adapters

File: adapters/gmail/gmail.go

GmailAdapter will be interface for UberFX

File: adapters/hotmail/hotmail.go
** Hotmail like gmail, just replace gmail with hotmail **

Create program

File: cmd/sender/main.go

NewEmailAdapter function will let UberFX know that IEmailPort interface will use Gmail adapter struct
We can switch adapter to hotmail by comment out return hotmail.NewHotmailAdapter() in function NewEmailAdapter

Entgo.io - Many to Many

Perm Chao — Mon, 05 May 2025 10:46:54 +0000

Entities

1) User
2) Post

Relationship

One user can have many groups
One group can have many users

Steps

1) Generate user and post

go run -mod=mod entgo.io/ent/cmd/ent new User
go run -mod=mod entgo.io/ent/cmd/ent new Group

2) Connect user with group

func (User) Edges() []ent.Edge {
    return []ent.Edge{
        edge.To("groups", Group.Type),
    }
}

3) Connect group with user

func (Group) Edges() []ent.Edge {
    return []ent.Edge{
        edge.From("users", User.Type).Ref("groups"),
    }
}

4) Try to create user and groups

func CreateUser(client *ent.Client, ctx context.Context) {
    // Create groups
    g1, _ := client.Group.Create().SetName("Group 1").Save(ctx)
    g2, _ := client.Group.Create().SetName("Group 2").Save(ctx)

    // Create user
    u, _ := client.User.Create().SetName("PP").AddGroups(g1, g2).Save(ctx)
}

5) Get user with groups

func CreateUser(client *ent.Client, ctx context.Context) {
    ...
    userWithGroups, _ := client.User.Query().WithGroups().Where(user.NameEQ("PP")).First(ctx)
    log.Println("user with groups", userWithGroups.Edges.Groups)
}

ลองใช้งาน jaeger ครั้งแรก

Perm Chao — Mon, 05 May 2025 10:30:57 +0000

โหลด Jaeger UI มาก่อน ในที่นี้ขอเลือกลงแบบง่ายๆผ่าน docker เพื่อทดสอบเฉยๆนะครับ

docker pull jaegertracing/all-in-one

docker run -d --name jaeger -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 -p 5775:5775/udp -p 6831:6831/udp -p 6832:6832/udp -p 5778:5778 -p 16686:16686 -p 14268:14268 -p 9411:9411 jaegertracing/all-in-one

ลองใช้กับ function ใน Node.js ผ่าน library opentracing

ลองใช้ Google Wire เพื่อทำ Dependency Injection ใน Go

Perm Chao — Sat, 06 Apr 2024 16:15:47 +0000

Wire is a code generation tool that automates connecting components using dependency injection

ลองใช้ Wire กับ Project API Todo แบบง่ายๆ

เครื่องมือที่ใช้

golang
go fiber
postgres

ขั้นตอน

เริ่มจากสร้างโปรเจคขึ้นมา 1 โปรเจคโดยมีไฟล์ในโฟรเดอร์ดังนี้

go.mod
cmd
- webservice
- main.go
- wire.go
controllers
- todo_controller.go
services
- config
- env.go
- db
- gorm.go
- server
- fiber.go

โฟกัสที่ file cmd/webservice/main.go สร้าง struct ขึ้นมาหนึ่งตัวและ function ที่ทำหน้าที่สร้าง struct ตัวนั้นเสมือนเป็น constructor

// vvvvvvvv สนใจ struct ตัวนี้ vvvvvvvv
type WebService struct {
 ENVConfig *config.ENVConfig
 DB        *gorm.DB
 TodoController *controllers.TodoController
}

// vvvvvvvv สนใจ function ตัวนี้ vvvvvvvv
func NewWebService(envConfig *config.ENVConfig, db *gorm.DB, todoController *controllers.TodoController) *WebService {
 return &WebService{
  DB: db,
  ENVConfig: envConfig,
  TodoController: todoController,
 }
}

func main() {
 // ยังไม่ต้องสนใจตรงนี้
}

ไปที่ file cmd/webservice/wire.go จะเห็นว่าที่ wire.Build(...) ใน ... จะต้องมี function ที่ return struct ที่เราสนใจจะใช้งานใน struct Webservice

// vvvvvvvv ต้องใส่นะ vvvvvvvv
//go:build wireinject
// +build wireinject

func InitWebservice() *Webservice {
    wire.Build(NewWebService, config.NewENVConfig, db.NewDB, controllers.NewTodoController)
    return &Webservice{}
}

กลับมาที่ file cmd/webservice/main.go แล้ว run คำสั่งใน terminal run คำสั่ง wire แล้วมันจะสร้าง file มาให้อันนึงชื่อ wire_gen.go ซึ่งในนั้นจะมี function InitWebservice มาให้ในแบบที่ inject ตัว dependencies ทั้งหมดที่จำเป็นมาให้แล้ว

func main() {
 webservice := InitWebservice()
}

ซึ่งถ้าต้องการเพิ่ม dependencies ต้องเพิ่ม 2 ที่
function New....(..., dependency ที่เราอยากเพิ่ม *DependencyStruct)
wire.Build(...., NewDependencyFn ที่ return dependency นั้นๆ) แล้ว wire จะไปหา dependency เหล่านั้นมาใส่ให้เราเอง ความ

ความรู้สึกหลังใช้

รู้สึกว่าไม่ค่อยจำเป็นต้องใช้มันเท่าไหร่ 555

Try using websocket with Go Fiber for the first time

Perm Chao — Sat, 08 Oct 2022 18:19:22 +0000

Objective

I want to implement simple chatroom with websocket (in go fiber middleware)

Step (code in every step will be in `main.go`)

1) make channels for receive commands chan and map channels and user in rooms

2) write function to receive command from connection

3) set endpoint to make connection

NestJS Micro-services 101 Part 1 - Try to communicate btw two services

Perm Chao — Sat, 01 Oct 2022 16:50:05 +0000

I try to learn NestJS Framework to make micro-services

Objective in Part 1

send simple message from one service to another service

// Project 1 api-gateway
nest new api-gateway

// Project ที่ 2 user-service
nest new user

User Request (http://localhost:3000) -> API Gateway -> User

Difference btw bootstrap in api-gateway and user

api-gateway main.ts

user main.ts

api-gateway service will know user service by register in api-gateway module

so you can declare user service proxy in constructor to send data into it, by
hello is event pattern

user service controller will receive event pattern name hello by use EventPattern decorator

So, this is response

Full code https://github.com/mossnana/nestjs/tree/microservices

Interface and DB in golang

Perm Chao — Sun, 06 Mar 2022 09:04:19 +0000

As implement hexagonal pattern (Ports and adapters pattern), our code should separate to three sections

API (Application Programming Interface) such your inbound (Gin, Echo, Fiber ...), Serialization or something else
Domain, Entity or something else that make your app unique
SPI (Service Programming Interface) such as external service, DB, DAO (Data Access Object) or something else

Example with below code, This will show relation with My Entity (Todo) and SPI(Database Insert)

Entity -> Todo struct
Port -> TodoHandler
Adapters -> todoAdapter interface, MySQLDB and MongoDB struct

package main

import (
    "log"

    "go.mongodb.org/mongo-driver/mongo"
    "gorm.io/gorm"
)

type Todo struct {
    ID          string
    Title       string
    Description string
}

type todoAdapter interface {
    Create(*Todo) error
}

type TodoHandler struct {
    adapter todoAdapter
}

type MySQLDB struct {
    db *gorm.DB
}

type MongoDB struct {
    db *mongo.Collection
}

func NewTodoHandler(adapter todoAdapter) *TodoHandler {
    return &TodoHandler{adapter: adapter}
}

func (db *MySQLDB) Create(todo *Todo) error {
    log.Println("🐟 MySQL Create Interface")

    // in real example, you can comment out below code
    // err := db.db.Create(todo)
    // return err

    return nil
}

func NewMySQLDB(db *gorm.DB) *MySQLDB {
    return &MySQLDB{db: db}
}

func (db *MongoDB) Create(todo *Todo) error {
    log.Println("✅ MongoDB Create Interface")

    // in real example, you can comment out below code
    // _, err := db.db.InsertOne(context.TODO(), todo)
    // return err

    return nil
}

func NewMongoDB(db *mongo.Collection) *MongoDB {
    return &MongoDB{db: db}
}

func main() {
    var todoHandler *TodoHandler

    // Todo insert with MySQL
    mysqlAdapter := NewMySQLDB(&gorm.DB{})
    todoHandler = NewTodoHandler(mysqlAdapter)
    todoHandler.adapter.Create(&Todo{
        ID: "1", Title: "New note", Description: "Save in mysql",
    })

    // Todo insert with MongoDB
    mongoAdapter := NewMongoDB(&mongo.Collection{})
    todoHandler = NewTodoHandler(mongoAdapter)
    todoHandler.adapter.Create(&Todo{
        ID: "1", Title: "New note", Description: "Save in mongo",
    })
}

In the example, you will see two adapters should implement Create method to related with adapter interface

And result will be like this

2022/03/06 15:35:46 🐟 MySQL Create Interface
2022/03/06 15:35:46 ✅ MongoDB Create Interface

Initial API project with Go

Perm Chao — Thu, 27 Jan 2022 10:22:39 +0000

เกริ่นนำ

เนื่องจากช่วงนี้ผมได้มาเริ่มต้นโปรเจค API ด้วย Golang บ่อย
ผมเลยขอบันทึกไว้กันลืม

Stack

1) Golang
2) Go Fiber
3) Gorm
4) PostgreSQL

Steps

1) สร้าง Folder สำหรับที่อยู่ของโปรเจค

$ mkdir demo
$ cd demo

2) สร้าง go mod file

$ go mod init github.com/mossnana/demo

3) สร้าง Folders / Files ที่เก็บ source code

$ mkdir cmd
$ mkdir internal
$ mkdir pkg

** Folder **

cmd ไว้วางโฟรเดอร์ที่มีไฟล์ main.go สำหรับโปรแกรมต่าง ๆ เช่น
- server ตัว run web server
- migrator ตัว migrate db
internal ไว้ใส่ไฟล์ที่เก็บ logic ที่เกี่ยวข้องกับตัว api นี้ ที่มีความเฉพาะตัวของ api นี้
pkg ไว้เก็บไฟล์ที่ไว้ต่อกับโปรแกรมนอก เช่น function ต่อ database ๆลๆ

4) สร้าง Folders / Files ที่ไว้ run
Dockerfile

FROM golang:latest
WORKDIR /app
COPY . .

RUN go mod tidy
RUN go get github.com/githubnemo/CompileDaemon
RUN go build -o bin/migrator ./cmd/migrator

CMD CompileDaemon --build="go build -o bin/server ./cmd/server" --command="./bin/server"

CompileDaemon ใช้เป็นตัว auto restart เมื่อ code เปลี่ยน

docker-compose.yml

version: "3.5"

services:
  demo_service:
    container_name: demo_service
    build:
      context: .
      dockerfile: Dockerfile
    volumes:
      - ./:/app
    restart: always
    ports:
      - "3000:3000"
    networks:
      - demo_net
    env_file:
      - ./.env

  brij_db:
    container_name: brij_db
    image: postgres:14
    volumes:
      - "demo_db_data:/var/lib/postgresql/data"
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_USER=demo
      - POSTGRES_PASSWORD=demopassword
      - POSTGRES_DB=demo
    networks:
      - demo_net

networks:
  demo_net:
    external: false

volumes:
  demo_db_data:
    external: false

Makefile

build:
    docker-compose up -d --build

start:
    docker-compose up -d

migrate:
    docker exec -it demo_service /app/bin/migrator

stop:
    docker-compose down

Project tree

.
├── cmd/
│   ├── demo/
│   │   └── main.go
│   └── migrator/
│       └── main.go
├── internal/
│   ├── model/
│   │   ├── sale.go
│   │   ├── purchase.go
│   │   └── account.go
│   ├── repository/
│   │   ├── sale.go
│   │   ├── purchase.go
│   │   └── account.go
│   ├── service/
│   │   ├── sale/
│   │   │   ├── v1/
│   │   │   │   ├── create.go
│   │   │   │   ├── read.go
│   │   │   │   ├── update.go
│   │   │   │   └── delete.go
│   │   │   └── v2/
│   │   │       ├── create.go
│   │   │       ├── read.go
│   │   │       ├── update.go
│   │   │       └── delete.go
│   │   └── ...
│   ├── handler/
│   │   └── sale/
│   │       ├── v1/
│   │       │   ├── create.go
│   │       │   ├── read.go
│   │       │   ├── update.go
│   │       │   └── delete.go
│   │       ├── v2/
│   │       │   ├── create.go
│   │       │   ├── read.go
│   │       │   ├── update.go
│   │       │   └── delete.go
│   │       └── ...
│   └── route/
│       ├── sale.go
│       ├── purchase.go
│       └── account.go
├── pkg/
│   ├── auth/
│   │   └── auth.go
│   └── gorm/
│       ├── driver.go
│       └── migrate.go
├── Dockerfile
├── docker-compose.yml
└── Makefile

การ Build

go build -o bin/{{ชื่อแอปใน main}} ./cmd/{{ชื่อแอปใน main}}

หัดใช้งาน GraphQL ด้วย Apollo Server

Perm Chao — Sat, 18 Sep 2021 02:39:24 +0000

1) เริ่มต้นการทำงานของ Apollo Server ด้วย Koa

app.ts

/*
import Koa from 'koa'
import Router from 'koa-router'
*/
// จาก lib `apollo-server-koa`
import { ApolloServer } from 'apollo-server-koa'

// ไฟล์นี้สร้างในข้อสอง
import graphqlSchema from './graphqlSchema'

/*
async function createApp(): Promise<Koa> {

 const application = new Koa()
 const router = new Router()
 */


 const graphqlServer = new ApolloServer({
  introspection: true,
  schema: graphqlSchema,
  context: ({ ctx }) => ctx
 })

 await graphqlServer.start()

 router.post("/graphql", graphqlServer.getMiddleware())
 router.get("/graphql", graphqlServer.getMiddleware())

 /*
 application.use(router.routes())
 return application

}
*/

2) กำหนด schema เริ่มต้น

schema.ts

import { GraphQLObjectType, GraphQLSchema } from 'graphql'
import GetUser from '.......'

export default new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'Query',
    fields: {
      // สามารถเพิ่มประเภทของการ Query ได้เรื่อย ๆ
      GetUser,
      .
      ..
      ...
    }
  }),
})

3) กำหนด Query GetUser

import User from '.......'

export default {
  type: User,
  resolve: async () => ({
    id: "test_id",
    name: "test_name"
  }),
}

4) กำหนด Schema User

import { GraphQLObjectType, GraphQLID, GraphQLString } from "graphql"

export const User = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: {
      type: GraphQLID,
    },
    name: {
      type: GraphQLString,
      resolve: async args => {
        // args จะเป็น resolve ของ query สามารถเอาไปใช้งานต่อได้
        console.log(args) // { id: 'test_id', name: 'test_name' }
        return 'finish'
      }
    }
  }),
})

มุมมองของสถาปัตยกรรมซอฟต์แวร์

Perm Chao — Wed, 08 Sep 2021 02:06:37 +0000

จากหนังสือ Fundamentals of Software Architecture

ได้พูดถึงมุมมองทั้งสี่ด้านเพื่อมองสถาปัตยกรรมของซอฟต์แวร์นั้นๆ

โครงสร้าง (Structure)
สมมุติว่ามีคนบอกว่าเราวางสถาปัตยกรรมของระบบไว้แบบ Microservices นั้นแปลว่าเค้ากำลังบอกคุณแค่โครงสร้างของระบบแต่ยังไม่ใช่สถาปัตยกรรมของระบบ
ซึ่งโครงสร้างในระบบมีหลายหลายแบบเช่น Microservices, Layered, Microkernel
คุณสมบัติ (Characteristic)
เป็นเกณฑ์ของซอฟต์แวร์นั้นๆที่ควรจะมีเช่น
- พร้อมใช้งานเสมอ (Availability)
- มีความน่าเชื่อถือ (Reliability)
- ทดสอบง่าย (Testability)
- ทนทานต่อการมีข้อผิดพลาด (Fault Tolerance)
การตัดสินใจ (Decision)
เป็นเหมือนกฏที่สร้างขึ้นมาในระบบว่าอะไรทำได้ อะไรทำไม่ได้ ค่อนข้างชัดเจน เช่น ใน Presentation layer ห้ามมีการเข้าถึง Database แต่จะอนุญาติเฉพาะ Business และ Services Layer เท่านั้น เป็นต้น
กฏบางอย่างสามารถเปลี่ยนแปลงได้แต่ต้องได้รับการอนุญาติจากหัวหน้าหรือที่ประชุม (แล้วแต่ระดับขององค์กร)
หลักการ (Design Principle)
เป็นคำแนะนำสำหรับการทำงานกับระบบนั้นๆ ซึ่งจะไม่ใช่เชิงบังคับว่าให้ทำเหมือน การตัดสินใจ (Decision) แต่เป็นคำแนะนำปลายเปิด เช่น สำหรับการส่งข้อมูลกันระหว่าง Services แนะนำให้ใช้เทคนิค asynchronous messaging เพื่อประสิทธิภาพของการทำงาน นั้นหมายถึงไม่ได้จำกัด รูปแบบการสื่อสาร (Protocol) หรือ เครื่องมือที่ใช้ นักพัฒนาสามารถเลือกได้ตามความถนัด

DEV Community: Perm Chao

Implement semaphore in golang by buffered channel

Getting started

Result from log

Remark

Code

Produce and consume Kafka message with samara and golang

Port and Adapter in Go with Uber FX

Case

Folder Structure

Steps

Create port

Create core business

Create adapters

Create program

Entgo.io - Many to Many

Entities

Relationship

Steps

ลองใช้งาน jaeger ครั้งแรก

ลองใช้ Google Wire เพื่อทำ Dependency Injection ใน Go

เครื่องมือที่ใช้

ขั้นตอน

ความรู้สึกหลังใช้

Try using websocket with Go Fiber for the first time

Objective

Step (code in every step will be in main.go)

NestJS Micro-services 101 Part 1 - Try to communicate btw two services

Objective in Part 1

Interface and DB in golang

Initial API project with Go

เกริ่นนำ

Stack

Steps

การ Build

หัดใช้งาน GraphQL ด้วย Apollo Server

มุมมองของสถาปัตยกรรมซอฟต์แวร์

Step (code in every step will be in `main.go`)