1.5K 69 43

Đã đăng vào thg 1 17, 2023 6:05 SA 5 phút đọc

608

[Go] Lambda CRUD với Postgres

Prepare

create simple lambda function, read blog: https://viblo.asia/p/golang-aws-lambda-thong-qua-serverless-framework-phan-1-EoW4ob9xVml
handle request and response in api: https://viblo.asia/p/golang-aws-lambda-thong-qua-serverless-framework-phan-2-5pPLkPY8VRZ

Mục tiêu

add new user
get user by id
update user
delete user

Khởi tạo project

Ở series này mình dùng serverless để làm việc với lambda(env, create, deploy,..)
Để biết chi tiết hơn, checkout link đọc thêm.

Script create table:

sql create table user

CREATE TABLE "users" (
  "id" bigserial,
  username character varying(50) COLLATE pg_catalog."default",
  name character varying(50) COLLATE pg_catalog."default" NOT NULL,
  phone character varying(50) COLLATE pg_catalog."default",
  PRIMARY KEY ("id")
);

model database

type UserModel struct {
  ID       uint   `gorm:"primarykey"`
  UserName string `gorm:"column:username" bson:"username"`
  Email    string `gorm:"column:email" bson:"email"`
  Phone    string `gorm:"column:phone" bson:"phone"`
}

List function

file serverless: https://github.com/ducnpdev/open-dev/blob/master/aws/lambda/crud/serverless.yml

Thêm 1 user

tạo endpoint trong file serverless:

functions:
  create:
    handler: bin/create # file binary sau khi build
    timeout: 3 # thời gian tối đa của functoin có thể xử lý 
    memorySize: 512 # resource memory được cấp phát cho function,
    description: create new user
    events:
      - http:
          path: /create # context-path
          method: post # method

Code implement:

function connection đến postgres database:

// load env from os, cast to struct
func loadConfig() Postgres {
    // những value khi get từ os lên thì đã được define trong file serverless.yaml
    user := os.Getenv("DB_USER")
    dbpass := os.Getenv("DB_PASS")
    dbhost := os.Getenv("DB_HOST")
    dbservice := os.Getenv("DB_SERVICE")
    return Postgres{
      Username: user,
      Password: dbpass,
      Database: dbservice,
      Host:     dbhost,
      Port:     5432,
    }
}
// create database postgres instance
func InitPostgres() (*gorm.DB, error) {
    log.Default().Println("connecting postgres database")
    config := loadConfig()
    dsn := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%d ", config.Host, config.Username, config.Password, config.Database, config.Port)
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Default().Println("connect postgres err:", err)
        return db, err
    }
    log.Default().Println("connect postgres successfully")
    return db, err
}

struct nhận request client:

type UserDTO struct {
  Email string `json:"email"`
  User  string `json:"userName"`
  Phone string `json:"phone"`
}

main function của lambda

func main() {
    lambda.Start(CreateUser)
}

function response data

func ParseResponse(respBody HttpResponse) string {
  respBody.Time = time.Now().Format("2006-01-02T15:04:05.000-07:00")
  if respBody.Err != nil {
    return responseErr(respBody)
  }
  return responseOk(respBody)
}

func responseOk(respBody HttpResponse) string {
  var buf bytes.Buffer
  mapRes := map[string]interface{}{
    "responseId":      respBody.Uuid,
    "responseMessage": "successfully",
    "responseTime":    respBody.Time,
  }
  if respBody.Data != nil {
    mapRes["data"] = respBody.Data
  }
  body, errMarshal := json.Marshal(mapRes)
  if errMarshal != nil {
    log.Default().Println("marshal response err", errMarshal)
  }
  json.HTMLEscape(&buf, body)
  return buf.String()
}

func responseErr(respBody HttpResponse) string {
  var buf bytes.Buffer
  mapRes := map[string]interface{}{
    "responseId":      respBody.Uuid,
    "responseMessage": respBody.Err.Error(),
    "responseTime":    respBody.Time,
  }

  body, errMarshal := json.Marshal(mapRes)
  if errMarshal != nil {
    log.Default().Println("marshal response err", errMarshal)
  }
  json.HTMLEscape(&buf, body)
  return buf.String()
}

function createUser

func CreateUser(ctx context.Context,
  eventReq events.APIGatewayProxyRequest) (Response, error) {
  var (
    req  = RequestBodyAPIGW{}
    resp = Response{
      StatusCode:      400,
      IsBase64Encoded: false,
      Headers: map[string]string{
        "Content-Type": "application/json",
      },
    }
  )
  err := json.Unmarshal([]byte(eventReq.Body), &req)
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{
      Uuid: req.RequestID,
      Err:  err,
    })
    return resp, nil
  }
  db, err := pkg.InitPostgres()
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{
      Uuid: req.RequestID,
      Err:  err,
    })
    resp.StatusCode = 500
    return resp, nil
  }
  // set http-code 200
  resp.StatusCode = 200
  // save new user
  err = db.Debug().Exec(`insert into users(username,email,phone) values(?,?,?)`, req.Data.User, req.Data.Email, req.Data.Phone).Error
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Err: err})
    return resp, nil
  }
  resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Data: nil})
  return resp, nil
}

Get user by id

tạo endpoint trong file serverless:

functions:
  read:
    handler: bin/read
    description: get user detail by id
    events:
      - http:
          path: /read
          method: get

Code implement:

Struct nhận request từ client

type UserDTO struct {
  ID string `json:"userId"`
}

function get user detail by id

func ReadUser(ctx context.Context,
  eventReq events.APIGatewayProxyRequest) (Response, error) {
  var (
    req  = RequestBodyAPIGW{}
    resp = Response{
      StatusCode:      400,
      IsBase64Encoded: false,
      Headers: map[string]string{
        "Content-Type": "application/json",
      },
    }
  )
  // get parameter from url
  req.Data.ID = eventReq.QueryStringParameters["id"]
  // init database,
  db, err := pkg.InitPostgres()

  if err != nil {
    resp.Body = ParseResponse(HttpResponse{
      Uuid: req.RequestID,
      Err:  err,
    })
    resp.StatusCode = 500
    return resp, nil
  }
  resp.StatusCode = 200
  var user = models.UserModel{}
  err = db.Table("users").Where("id = ?", req.Data.ID).First(&user).Error
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Err: err})
    return resp, nil
  }
  resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Data: user})
  return resp, nil
}

Get update user

tạo endpoint trong file serverless

functions:
  update:
    handler: bin/update
    description: update user by id
    events:
      - http:
          path: /update
          method: post

Struct nhận request từ client

  type UserDTO struct {
    ID    int    `json:"userId"`
    Email string `json:"email"`
    Phone string `json:"phone"`
  }

Code implement

function get update user

func UpdateUser(ctx context.Context, eventReq events. APIGatewayProxyRequest) (Response, error) {
  var (
    req  = RequestBodyAPIGW{}
    resp = Response{
      StatusCode:      400,
      IsBase64Encoded: false,
      Headers: map[string]string{
        "Content-Type": "application/json",
      },
    }
  )
  err := json.Unmarshal([]byte(eventReq.Body), &req)
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{
      Uuid: req.RequestID,
      Err:  err,
    })
    return resp, nil
  }
  db, err := pkg.InitPostgres()

  if err != nil {
    resp.Body = ParseResponse(HttpResponse{
      Uuid: req.RequestID,
      Err:  err,
    })
    resp.StatusCode = 500
    return resp, nil
  }
  resp.StatusCode = 200
  err = db.Exec(`update users set email = ?, phone = ? where id = ?`, req.Data.Email, req.Data.Phone, req.Data.ID).Error
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Err: err})
    return resp, nil
  }
  resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Data: nil})
  return resp, nil
}

Detele user

tạo endpoint trong file serverless

functions:
  delete:
    handler: bin/delete
    description: delete user by id
    events:
      - http:
          path: /delete
          method: post

Struct nhận request từ client

  type UserDTO struct {
    ID    int    `json:"userId"`
  }

Code implement

function get delete user by id

func DeleteUser(ctx context.Context, eventReq events.APIGatewayProxyRequest) (Response, error) {
  var (
    req  = RequestBodyAPIGW{}
    resp = Response{
      StatusCode:      400,
      IsBase64Encoded: false,
      Headers: map[string]string{
        "Content-Type": "application/json",
      },
    }
  )
  err := json.Unmarshal([]byte(eventReq.Body), &req)
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{
      Uuid: req.RequestID,
      Err:  err,
    })
    return resp, nil
  }
  db, err := pkg.InitPostgres()
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{
      Uuid: req.RequestID,
      Err:  err,
    })
    resp.StatusCode = 500
    return resp, nil
  }
  resp.StatusCode = 200
  var user = models.UserModel{}
  err = db.Debug().Table("users").Delete(&user, req.Data.ID).Error
  if err != nil {
    resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Err: err})
    return resp, nil
  }
  resp.Body = ParseResponse(HttpResponse{Uuid: req.RequestID, Data: req.Data})
  return resp, nil
}

Prepare

Mục tiêu

Khởi tạo project

Script create table:

List function

Thêm 1 user

Get user by id

Get update user

Detele user

Mục lục