[AWS Serverless] - Sử dụng Golang để kết nối Postgresql Database thực hiện CURD

Serverless là gì

Hãy xem lại bài viết này của mình để nắm căn bản phần Serverless này.

Mô hình hệ thống chúng ta sẽ xây dựng hôm nay

Giới thiệu ElephantSQL và tạo một DB Instance miễn phí

ElephantSQL là một trang web cho phép chúng ta tạo các Database Instance để phục vụ cho việc lưu trữ dữ liệu của chúng ta, có nhiều gói(plans) cho các bạn lựa chọn. Các gói trải dài từ miễn phí đến cao nhất là gói $2798/tháng.

Trong bài viết hôm nay mình chỉ sử dụng gói Free cho mục đích demo. Các bạn có thể vào link này để tạo cho mình một DB Instance để sử dụng thử.

Chuẩn bị môi trường

Cài đặt Nodejs(Vì mục 2 cài bằng NPM), chi tiết ở link này
Cài đặt Serverless Framework, chi tiết ở link này
Cài đặt AWS CLI, chi tiết ở link này
Cài đặt Golang, chi tiết ở link này
Do ví dụ sử dụng lệnh make nên mình sử dụng Ubuntu/MacOS.
Tạo Database Instace trong ElephantSQL và vào phần details để lấy connection string(hình minh họa bên dưới).

Cài đặt AWS CLI để kết nối tài khoản AWS của bạn

aws configure

Các bạn cài đặt Client ID và Client Secret như bên dưới, 2 thông số còn lại optional bạn không cài cũng được.

AWS Access Key ID [****]:
AWS Secret Access Key [****]:
Default region name [us-west-1]: 
Default output format [None]:

Hãy xem cấu trúc chính của sourcecode nào !

Các bạn clone sourcecode mình viết về máy bằng lệnh bên dưới (hãy cho mình một star để ủng hộ mình ra thêm nhiều bài viết và source mẫu nhé):

git clone https://github.com/tanthanhkid/serverless-aws-golang-curd-postgresql-boilerplate.git

Đầu tiên chúng ta xem file serverless.yml để xem các thành phần mà source Serverless này sẽ tạo trên account AWS của chúng ta.

serverless.yml

Đoạn này nói cho chúng ta biết sourcecode này sẽ deploy lên tài khoản AWS với runtime của Golang và version 1.x ở Region ap-southeast-1(Singapore). Ngoài ra, bên dưới còn cho chúng ta điền thêm một biến môi trường của Lambda, nơi chúng ta sẽ để connection string và để khi code chạy sẽ lấy connection string từ đây ra để kết nối vào DB Instance.

provider:
  name: aws
  runtime: go1.x
  region: ap-southeast-1
  environment: 
    RDS_CONN_STRING: postgres://<username>:<password>@<db url>  # các bạn thay thế connection string ở bước 6 phía trên vào đây nhé

Đoạn code bên dưới mình có bổ sung thêm phần bảo mật so với bài trước, Bởi vì API của chúng ta public internet, nên việc vô tình lộ URL và Request có thể dẫn tới bị tấn công từ các bên có chủ đích phá hoại. Hậu quả có thể xảy ra là dịch vụ của chúng ta bị dừng hoạt động hoặc quá tải, bill AWS tăng đột biến.

Cách xử lý là chúng ta phải có một x-api-key(được in ra trong console sau khi deploy serverless hoặc các bạn vào AWS Console để lấy) gắn vào header như sau:

plugins:
  - serverless-add-api-key

custom:
  apiKeys:
    dev:
    - name: baitap2
      usagePlan:
        name: "baitap2" 
        description: "Description of first plan"
        quota:
          limit: 100000  # ở đây mình cho 10k request/tháng, nếu vô tình client làm lộ key thì chỉ mất 10k request và chúng ta hoàn toàn có thể kiểm soát tình hình bằng nhiều cách phản ứng khác nhau, ví dụ disable và tạo key mới
          period: MONTH
        throttle:  # cấu hình này cho phép chúng ta kiểm soát số lượng request được xử lý cùng lúc
          burstLimit: 100
          rateLimit: 20

Đến phần cuối cùng của file serverless.yml chúng ta sẽ phân tích đoạn code dùng để tạo AWS Lambda bằng Golang, chúng ta có 4 function và Insert, Update, Delete và GetUsers được mô tả khá tường minh trên source yml.

postinsert: 
    handler: bin/postInsert # các bạn xem file MakeFile sẽ thấy code Go được build ra bin và chỗ này lấy file build và đẩy lên AWS
    package:
      include:
        - ./bin/postInsert
    events:
      - http:
          path: insert  # các bạn gọi vào thông qua path /insert
          method: post  # HTTP Method là POST
          private: true # true để bật chức năng xác thực x-api-key trước khi xử lý tiếp
  postupdate:
    handler: bin/postUpdate
    package:
      include:
        - ./bin/postUpdate
    events:
      - http:
          path: update
          method: post      
          private: true
  postdelete:
    handler: bin/postDelete
    package:
      include:
        - ./bin/postDelete
    events:
      - http:
          path: delete
          method: post          
          private: true
  postgetusers:
    handler: bin/postGetUsers
    package:
      include:
        - ./bin/postGetUsers
    events:
      - http:
          path: getusers
          method: post          
          private: true

Tiếp theo chúng ta hãy xem tới phần sourcecode của Golang khi CURD vào PostgreSQL nhé.

postInsert/postInsert.go

Chúng ta sẽ cần phải tạo connection tới DB, bạn có thể thấy connection string phía trên được truy xuất ở trong hàm này.

func createConnection() *sql.DB {
	connStr := os.Getenv("RDS_CONN_STRING")

	fmt.Println("connection string: " + connStr)

	// Open the connection
	db, err := sql.Open("postgres", connStr)

	if err != nil {
		fmt.Println("Open connection - err: " + err.Error())
		panic(err)
	}

	// check the connection
	err = db.Ping()

	if err != nil {
		fmt.Println("Ping database connection - err: " + err.Error())
		panic(err)
	}

	fmt.Println("connected to database!")

	return db
}

Sau đó chúng ta sẽ viết tiếp hàm insert.

func insertUser(user models.User) int64 {

	//create connection
	db := createConnection()

	//close the connection
	defer db.Close()

	//create insert query
	sqlStatement := `INSERT INTO users (name, username, phone) VALUES ($1, $2, $3) RETURNING id`

	// the inserted id will store in this id
	var id int64

	err := db.QueryRow(sqlStatement, user.Name, user.UserName, user.Phone).Scan(&id)

	if err != nil {
		fmt.Println("system err:" + err.Error())
	}
	if id > 0 {
		fmt.Println("insert user success!")
	}

	return id
}

Quay lại Handler của chúng ta, ở dòng 72 tới 77 chúng ta sẽ gọi hàm insert sau khi parse dữ liệu từ Body Request.

var user models.User
user.Name = bodyRequest.Data.Name
user.UserName = bodyRequest.Data.UserName
user.Phone = bodyRequest.Data.Phone

id := insertUser(user)

Tiếp theo đó tới phần build code và đẩy lên AWS. khi chạy lệnh make deploy thì MakeFile sẽ lần lượt chạy vào các folder và build source Go thành các gói và để trong folder /bin. Cuối cùng, chạy lệnh sls deploy để bắt đầu quá trình build và deploy lên AWS.

MakeFile

.PHONY: build clean deploy

build: 
	cd postInsert && env GOARCH=amd64 GOOS=linux CGO_ENABLED=0 go build -ldflags="-s -w" -o ../bin/postInsert ./postInsert.go && cd ..
	cd postUpdate && env GOARCH=amd64 GOOS=linux CGO_ENABLED=0 go build -ldflags="-s -w" -o ../bin/postUpdate ./postUpdate.go && cd ..
	cd postDelete && env GOARCH=amd64 GOOS=linux CGO_ENABLED=0 go build -ldflags="-s -w" -o ../bin/postDelete ./postDelete.go && cd ..
	cd postGetUsers && env GOARCH=amd64 GOOS=linux CGO_ENABLED=0 go build -ldflags="-s -w" -o ../bin/postGetUsers ./postGetUsers.go && cd ..

clean:
	rm -rf ./bin ./vendor Gopkg.lock
 
deploy: clean build
	sls deploy --verbose