go-gin + mysql + gorm + Dockerで開発用APIサーバーを立ててみた

簡易なウェブアプリが作りたくて、そのときのメモです。
go-ginでAPIサーバーを立ててデータベースと通信できるようにします。

Github Repositoryを作りました。

OS

• macOS Catalina

使う技術スタック

• gin (ウェブサーバー)
• dlv (デバッグ)
• air (ホットリロード)
• gorm (ORMライブラリ)
• mysql
• golang-migrate (マイグレーション)
• docker

あると便利なアプリ

• postman (rest api通信確認)
• goland (デバッグ、開発)
• sequel pro (データベース確認)

ディレクトリ構造

最終的には以下のようになっています。

.
├── backend
│   ├── Dockerfile.local
│   ├── article
│   │   └── article.go
│   ├── go.mod
│   ├── go.sum
│   ├── handler
│   │   ├── articleFunc.go
│   │   └── userFunc.go
│   ├── lib
│   │   └── sql_handler.go
│   ├── main.go
│   ├── migration
│   │   ├── main.go
│   │   └── migrations
│   │       ├── 1_articles.down.sql
│   │       ├── 1_articles.up.sql
│   │       ├── 2_users.down.sql
│   │       └── 2_users.up.sql
│   ├── tmp
│   │   └── main
│   └── user
│       └── user.go
├── docker-compose.yml
└── mysql
    ├── Dockerfile
    └── my.cnf

9 directories, 18 files

気をつけるところ

github.com/自分のアカウント/自分のレポジトリ/main.goが存在するフォルダのところは各自書き換えてください。

ディレクトリ

next-gin-mysqlという名前で立ち上げます。(nextをフロントエンドとして立ち上げたいのですが、記事の長さ的にそれは次回にします）

$ mkdir next-gin-mysql

バックエンド側

まずディレクトリを作ります。

next-gin-mysql $ mkdir backend

go moduleの用意

go modulesの用意をします。
github.com/自分のアカウント/自分のレポジトリ/main.goが存在するフォルダで初期化するとやりやすいと思います。

next-gin-mysql/backend $ go mod init github.com/greenteabiscuit/next-gin-mysql/backend

next-gin-mysql/backend $ go get -u github.com/gin-gonic/gin

これで ginとその依存パッケージがダウンロードされます。

それぞれのファイルの用意

サーバーを立ち上げるmain.goです。データベース用のlib、記事とユーザーのモデル、そしてハンドラはあとで書きます。

main.go

package main

import (
	"os"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/greenteabiscuit/next-gin-mysql/backend/article"
	"github.com/greenteabiscuit/next-gin-mysql/backend/handler"
	"github.com/greenteabiscuit/next-gin-mysql/backend/lib"
	"github.com/greenteabiscuit/next-gin-mysql/backend/user"
	"github.com/joho/godotenv"

	"github.com/gin-contrib/cors"
)

func main() {
	if os.Getenv("USE_HEROKU") != "1" {
		err := godotenv.Load()
		if err != nil {
			panic(err)
		}
	}

	article := article.New()
	user := user.New()

	lib.DBOpen()
	defer lib.DBClose()

	r := gin.Default()

	r.Use(cors.New(cors.Config{
		AllowOrigins: []string{
			"http://localhost:3000",
		},
		AllowMethods: []string{
			"POST",
			"GET",
			"OPTIONS",
		},
		AllowHeaders: []string{
			"Access-Control-Allow-Credentials",
			"Access-Control-Allow-Headers",
			"Content-Type",
			"Content-Length",
			"Accept-Encoding",
			"Authorization",
		},
		AllowCredentials: true,
		MaxAge:           24 * time.Hour,
	}))

	r.GET("/article", handler.ArticlesGet(article))
	r.POST("/article", handler.ArticlePost(article))
	r.POST("/user/login", handler.UserPost(user))

	r.Run(os.Getenv("HTTP_HOST") + ":" + os.Getenv("HTTP_PORT")) // listen and serve on 0.0.0.0:8080
}

記事を扱うarticleのハンドラパッケージです。

handler/articleFunc.go

package handler

import (
	"net/http"

	"github.com/greenteabiscuit/next-gin-mysql/backend/article"

	"github.com/gin-gonic/gin"
)

func ArticlesGet(articles *article.Articles) gin.HandlerFunc {
	return func(c *gin.Context) {
		result := articles.GetAll()
		c.JSON(http.StatusOK, result)
	}
}

type ArticlePostRequest struct {
	Title       string `json:"title"`
	Description string `json:"description"`
}

func ArticlePost(post *article.Articles) gin.HandlerFunc {
	return func(c *gin.Context) {
		requestBody := ArticlePostRequest{}
		c.Bind(&requestBody)

		item := article.Article{
			Title:       requestBody.Title,
			Description: requestBody.Description,
		}
		post.Add(item)

		c.Status(http.StatusNoContent)
	}
}

userのハンドラ関数は以下です。

handler/userFunc.go

package handler

import (
	"net/http"

	"github.com/greenteabiscuit/next-gin-mysql/backend/user"

	"github.com/gin-gonic/gin"
)

func UsersGet(users *user.Users) gin.HandlerFunc {
	return func(c *gin.Context) {
		result := users.GetAll()
		c.JSON(http.StatusOK, result)
	}
}

type UserPostRequest struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

func UserPost(post *user.Users) gin.HandlerFunc {
	return func(c *gin.Context) {
		requestBody := UserPostRequest{}
		c.Bind(&requestBody)

		item := user.User{
			Username: requestBody.Username,
			Password: requestBody.Password,
		}
		post.Add(item)

		c.Status(http.StatusNoContent)
	}
}

articleの構造体などを定義するファイルです。

article/article.go

package article

import (
	"fmt"

	"github.com/greenteabiscuit/next-gin-mysql/backend/lib"
)

type Article struct {
	Title       string `json:"title"`
	Description string `json:"description"`
}

type Articles struct {
	Items []Article
}

func New() *Articles {
	return &Articles{}
}

func (r *Articles) Add(a Article) {
	r.Items = append(r.Items, a)
	db := lib.GetDBConn().DB
	if err := db.Create(a).Error; err != nil {
		fmt.Println("err!")
	}
}

func (r *Articles) GetAll() []Article {
	db := lib.GetDBConn().DB
	var articles []Article
	if err := db.Find(&articles).Error; err != nil {
		return nil
	}
	return articles
}

userの構造体をまとめたファイルです。ちょっとここはテキトーなのでもう少し直したい、、、

user/user.go

package user

import (
	"fmt"

	"github.com/greenteabiscuit/next-gin-mysql/backend/lib"
)

type User struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type Users struct {
	Items []User
}

func New() *Users {
	return &Users{}
}

func (r *Users) Add(a User) {
	r.Items = append(r.Items, a)
	db := lib.GetDBConn().DB
	if err := db.Create(a).Error; err != nil {
		fmt.Println("err!")
	}
}

func (r *Users) GetAll() []User {
	db := lib.GetDBConn().DB
	var users []User
	if err := db.Find(&users).Error; err != nil {
		return nil
	}
	return users
}

mysqlと接続を行う sql_handler.goも追加します。

lib/sql_handler.go

package lib

import (
	"fmt"
	"os"
	"time"

	"gorm.io/gorm"

	"gorm.io/driver/mysql"
)

// SQLHandler ...
type SQLHandler struct {
	DB  *gorm.DB
	Err error
}

var dbConn *SQLHandler

// DBOpen は DB connectionを張る。
func DBOpen() {
	dbConn = NewSQLHandler()
}

// DBClose は DB connectionを張る。
func DBClose() {
	sqlDB, _ := dbConn.DB.DB()
	sqlDB.Close()
}

// NewSQLHandler ...
func NewSQLHandler() *SQLHandler {
	user := os.Getenv("DB_USERNAME")
	password := os.Getenv("DB_PASSWORD")
	host := os.Getenv("DB_HOST")
	port := os.Getenv("DB_PORT")
	dbName := os.Getenv("DB_DATABASE")
	fmt.Println(user, password, host, port)

	var db *gorm.DB
	var err error
	// Todo: USE_HEROKU = 1のときと場合分け
	if os.Getenv("USE_HEROKU") != "1" {
		dsn := user + ":" + password + "@tcp(" + host + ":" + port + ")/" + dbName + "?parseTime=true&loc=Asia%2FTokyo"
		db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
		if err != nil {
			panic(err)
		}
	} /*else {
		var (
			instanceConnectionName = os.Getenv("DB_CONNECTION_NAME") // e.g. 'project:region:instance'
		)
		dbURI := fmt.Sprintf("%s:%s@unix(/cloudsql/%s)/%s?parseTime=true", user, password, instanceConnectionName, database)
		// dbPool is the pool of database connections.
		db, err = gorm.Open(mysql.Open(dbURI), &gorm.Config{})
		if err != nil {
			panic(err)
		}
	}*/

	sqlDB, _ := db.DB()
	//コネクションプールの最大接続数を設定。
	sqlDB.SetMaxIdleConns(100)
	//接続の最大数を設定。 nに0以下の値を設定で、接続数は無制限。
	sqlDB.SetMaxOpenConns(100)
	//接続の再利用が可能な時間を設定。dに0以下の値を設定で、ずっと再利用可能。
	sqlDB.SetConnMaxLifetime(100 * time.Second)

	sqlHandler := new(SQLHandler)
	db.Logger.LogMode(4)
	sqlHandler.DB = db

	return sqlHandler
}

// GetDBConn ...
func GetDBConn() *SQLHandler {
	return dbConn
}

// BeginTransaction ...
func BeginTransaction() *gorm.DB {
	dbConn.DB = dbConn.DB.Begin()
	return dbConn.DB
}

// Rollback ...
func RollBack() {
	dbConn.DB.Rollback()
}

ローカル開発環境の整備

docker-composeで一発でサーバーをすべて立ち上げるようにします。このときについでに mysqlの準備とデバッグサーバーの準備もしておきます。

docker-compose.yml

version: '3'
services:
    go:
        build:
            context: ./backend
            dockerfile: Dockerfile.local
        volumes:
            - ./backend:/go/src/backend
        working_dir: /go/src/backend
        environment:
            TZ: Asia/Tokyo
        ports:
            - 8080:8080
            - 2345:2345
        security_opt: 
            - apparmor:unconfined
        cap_add: 
            - SYS_PTRACE

    mysql:
        build: ./mysql
        environment:
            TZ: Asia/Tokyo
            MYSQL_ROOT_PASSWORD: root
            MYSQL_DATABASE: backend
        ports:
            - 13306:3306
        volumes:
            - mysql_volume:/var/lib/mysql
    
volumes:
    mysql_volume:

go用のDockerfileです。今後デプロイ用のDockerfileと分けるかもしれないので、一応Dockerfile.localにしておきます。

backend/Dockerfile.local

FROM golang:1.15.2
COPY . /go/src/sample
WORKDIR /go/src/sample
RUN go get -u github.com/cosmtrek/air
RUN go get -u github.com/go-delve/delve/cmd/dlv
CMD ["air", "-c", ".air.toml"]**

ホットリロードするために、airを使います。
airの設定ファイルである.air.tomlはairの本家レポジトリから引っ張ってくることができます。

backend/.air.toml

# Config file for [Air](https://github.com/cosmtrek/air) in TOML format
# Working directory
# . or absolute path, please note that the directories following must be under root.
root = "."
tmp_dir = "tmp"
[build]
# Just plain old shell command. You could use `make` as well.
cmd = "go build -o ./tmp/main ."
# Binary file yields from `cmd`.
bin = "tmp/main"
# Customize binary.
full_bin = "APP_ENV=dev APP_USER=air /go/bin/dlv exec ./tmp/main --headless=true --listen=:2345 --api-version=2 --accept-multiclient"
# Watch these filename extensions.
include_ext = ["go", "tpl", "tmpl", "html"]
# Ignore these filename extensions or directories.
exclude_dir = ["assets", "tmp", "vendor", "frontend/node_modules", "storage"]
# Watch these directories if you specified.
include_dir = []
# Exclude files.
exclude_file = []
# Exclude unchanged files.
exclude_unchanged = true
# This log file places in your tmp_dir.
log = "air.log"
# It's not necessary to trigger build each time file changes if it's too frequent.
delay = 1000 # ms
# Stop running old binary when build errors occur.
stop_on_error = true
# Send Interrupt signal before killing process (windows does not support this feature)
send_interrupt = false
# Delay after sending Interrupt signal
kill_delay = 500 # ms
[log]
# Show log time
time = false
[color]
# Customize each part's color. If no color found, use the raw app log.
main = "magenta"
watcher = "cyan"
build = "yellow"
runner = "green"
[misc]
# Delete tmp directory on exit
clean_on_exit = true

mysqlの設定ファイルです。

mysql/my.cnf

# MySQLサーバーへの設定
[mysqld]
# 文字コード/照合順序の設定
character_set_server=utf8mb4
collation_server=utf8mb4_bin

# タイムゾーンの設定
default_time_zone=SYSTEM
log_timestamps=SYSTEM

# デフォルト認証プラグインの設定
default_authentication_plugin=mysql_native_password

# mysqlオプションの設定
[mysql]
# 文字コードの設定
default_character_set=utf8mb4

# mysqlクライアントツールの設定
[client]
# 文字コードの設定
default_character_set=utf8mb4

mysqlのDockerfileです。

FROM mysql:8.0.21
# FROM mysql@sha256:77b7e09c906615c1bb59b2e9d7703f728b1186a5a70e547ce2f1079ef4c1c5ca

RUN echo "USE mysql;" > /docker-entrypoint-initdb.d/timezones.sql &&  mysql_tzinfo_to_sql /usr/share/zoneinfo >> /docker-entrypoint-initdb.d/timezones.sql

COPY ./my.cnf /etc/mysql/conf.d/my.cnf

環境変数も設定しておきます。本番環境では見せないようにしましょう。
DB_HOSTはコンテナの名前で選ぶので、mysqlにしてあります。

backend/.env

HTTP_HOST=""
HTTP_PORT=8080
DB_HOST="mysql"
DB_PORT=3306
DB_USERNAME=root
DB_PASSWORD=root
DB_DATABASE=backend

立ち上げてみる

サーバーを立ち上げてみましょう。以下のようにエラーが起きずに 2345が出てきたらとりあえずOKです。

docker-compose up --build

mysql_1  | 2021-05-04T16:29:33.735276+09:00 0 [Warning] [MY-011810] [Server] Insecure configuration for --pid-file: Location '/var/run/mysqld' in the path is accessible to all OS users. Consider choosing a different directory.
mysql_1  | 2021-05-04T16:29:33.770064+09:00 0 [System] [MY-010931] [Server] /usr/sbin/mysqld: ready for connections. Version: '8.0.21'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  MySQL Community Server - GPL.
go_1     | watching user
go_1     | building...
go_1     | running...
go_1     | API server listening at: [::]:2345

golandでの設定

golandで開発するのがやりやすいと思います。
今はデバッグのサーバしか立ち上がっていないので、ここで設定を行います。
delveのプロセスを走らせることで、APIサーバーも立ち上がるようになります。

メニューのdebugをクリックし、go remoteを選びます。

適当な名前をつけて、applyとdebugをクリックします。

これでコマンドラインでもサーバが立ち上がっています。ただまだマイグレーションができていないので、データベースなどからデータが取得できません。

go_1     | API server listening at: [::]:2345
go_1     | [GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
go_1     | 
go_1     | [GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
go_1     |  - using env:	export GIN_MODE=release
go_1     |  - using code:	gin.SetMode(gin.ReleaseMode)
go_1     | 
go_1     | [GIN-debug] GET    /article                  --> github.com/greenteabiscuit/next-gin-mysql/backend/handler.ArticlesGet.func1 (3 handlers)
go_1     | [GIN-debug] POST   /article                  --> github.com/greenteabiscuit/next-gin-mysql/backend/handler.ArticlePost.func1 (3 handlers)
go_1     | [GIN-debug] Environment variable PORT is undefined. Using port :8080 by default
go_1     | [GIN-debug] Listening and serving HTTP on :8080

マイグレーション

golang-migrateを使ってmysqlデータベースを立ち上げます。migrationというフォルダをbackend直下に作ります。

backend $ mkdir migration

以下のような構造になります。main.goでmigrationの処理を書きます。

migration $ tree
.
├── main.go
└── migrations
    ├── 1_articles.down.sql
    ├── 1_articles.up.sql
    ├── 2_users.down.sql
    └── 2_users.up.sql

migrationの.env

先ほどと同じになりますが、なるべく見せないようにしましょう。今回はローカルなので大丈夫かと思いますが。

migration/.env

HTTP_HOST=""
HTTP_PORT=8080
DB_HOST="mysql"
DB_PORT=3306
DB_USERNAME=root
DB_PASSWORD=root
DB_DATABASE=backend

migration の main.go

migration/main.go

package main

import (
	"database/sql"
	"flag"
	"fmt"
	"os"
	"time"

	_ "github.com/go-sql-driver/mysql"
	"github.com/golang-migrate/migrate"
	"github.com/golang-migrate/migrate/database/mysql"
	_ "github.com/golang-migrate/migrate/source/file"
	"github.com/joho/godotenv"
	"github.com/pkg/errors"
)

var migrationFilePath = "file://./migrations/"

func main() {
	fmt.Println("start migration")
	flag.Parse()
	command := flag.Arg(0)
	migrationFileName := flag.Arg(1)

	if command == "" {
		showUsage()
		os.Exit(1)
	}

	if os.Getenv("USE_HEROKU") != "1" {
		err := godotenv.Load()
		if err != nil {
			fmt.Println(errors.Wrap(err, "load error .env"))
		}
	}

	m := newMigrate()
	version, dirty, _ := m.Version()
	force := flag.Bool("f", false, "force execute fixed sql")
	if dirty && *force {
		fmt.Println("force=true: force execute current version sql")
		m.Force(int(version))
	}

	switch command {
	case "new":
		newMigration(migrationFileName)
	case "up":
		up(m)
	case "down":
		down(m)
	case "drop":
		drop(m)
	case "version":
		showVersionInfo(m.Version())
	default:
		fmt.Println("\nerror: invalid command '", command, "'")
		showUsage()
		os.Exit(0)
	}
}

func generateDsn() string {
	apiRevision := os.Getenv("API_REVISION")
	var dsn string

	if apiRevision == "release" {
		dsn = os.Getenv("DATABASE_URL") + "&multiStatements=true" // heroku対応
	} else {
		user := os.Getenv("DB_USERNAME")
		pass := os.Getenv("DB_PASSWORD")
		host := os.Getenv("DB_HOST")
		port := os.Getenv("DB_PORT")
		dbName := os.Getenv("DB_DATABASE")

		dsn = fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true&multiStatements=true", user, pass, host, port, dbName)
	}

	return dsn
}

func newMigrate() *migrate.Migrate {
	dsn := generateDsn()
	db, openErr := sql.Open("mysql", dsn)
	if openErr != nil {
		fmt.Println(errors.Wrap(openErr, "error occurred. sql.Open()"))
		os.Exit(1)
	}

	driver, instanceErr := mysql.WithInstance(db, &mysql.Config{})
	if instanceErr != nil {
		fmt.Println(errors.Wrap(instanceErr, "error occurred. mysql.WithInstance()"))
		os.Exit(1)
	}

	m, err := migrate.NewWithDatabaseInstance(
		migrationFilePath,
		"mysql",
		driver,
	)

	if err != nil {
		fmt.Println(errors.Wrap(err, "error occurred. migrate.NewWithDatabaseInstance()"))
		os.Exit(1)
	}
	return m
}

func showUsage() {
	fmt.Println(`
-------------------------------------
Usage:
  go run migration/main.go <command>
Commands:
  new FILENAME	Create new up & down migration files
  up		Apply up migrations
  down		Apply down migrations
  drop		Drop everything
  version	Check current migrate version
-------------------------------------`)
}

func newMigration(name string) {
	if name == "" {
		fmt.Println("\nerror: migration file name must be supplied as an argument")
		os.Exit(1)
	}
	base := fmt.Sprintf("./migration/migrations/%s_%s", time.Now().Format("20060102030405"), name)
	ext := ".sql"
	createFile(base + ".up" + ext)
	createFile(base + ".down" + ext)
}

func createFile(fname string) {
	if _, err := os.Create(fname); err != nil {
		panic(err)
	}
}

func up(m *migrate.Migrate) {
	fmt.Println("Before:")
	showVersionInfo(m.Version())
	err := m.Up()
	if err != nil {
		if err.Error() != "no change" {
			panic(err)
		}
		fmt.Println("\nno change")
	} else {
		fmt.Println("\nUpdated:")
		version, dirty, err := m.Version()
		showVersionInfo(version, dirty, err)
	}
}

func down(m *migrate.Migrate) {
	fmt.Println("Before:")
	showVersionInfo(m.Version())
	err := m.Steps(-1)
	if err != nil {
		panic(err)
	} else {
		fmt.Println("\nUpdated:")
		showVersionInfo(m.Version())
	}
}

func drop(m *migrate.Migrate) {
	err := m.Drop()
	if err != nil {
		panic(err)
	} else {
		fmt.Println("Dropped all migrations")
		return
	}
}

func showVersionInfo(version uint, dirty bool, err error) {
	fmt.Println("-------------------")
	fmt.Println("version : ", version)
	fmt.Println("dirty   : ", dirty)
	fmt.Println("error   : ", err)
	fmt.Println("-------------------")
}

マイグレーションのためのsqlファイル

1_articles.down.sql

drop table if exists articles

1_articles.up.sql

create table if not exists articles (
    id integer auto_increment primary key,
    title varchar(40),
    description varchar(40)
)

2_users.down.sql

drop table if exists users

2_users.up.sql

create table if not exists users (
    id integer auto_increment primary key,
    username varchar(40),
    password varchar(40)
)

マイグレーションする

dockerコンテナに入ってマイグレーションします。go run main.go upでマイグレーションが行われます。

$ docker exec -it container_name bash
# cd migration
# go run main.go up

start migration
Before:
-------------------
version :  0
dirty   :  false
error   :  no migration
-------------------

Updated:
-------------------
version :  2
dirty   :  false
error   :  <nil>
-------------------

これでｄｂでもテーブルができているのを確認したらOKです！
Sequel Proなどのアプリで確認できます。

PostmanでのAPI確認

これは Postmanというデスクトップアプリで確認することができます。

Post

JSON形式で送ります。

GET

データベースにも hoge と hello worldが入っているのが確認できました。

コマンドラインでもカラフルに表示されています。

まとめ

air + gin + gorm + golang-migrate + mysql + delve + dockerで開発用APIサーバーを立ち上げることができました。

今後試してみたいこと

• herokuにデプロイしてみる
• userのところの処理がテキトーなままなので直します、、、
• フロントエンド（next + reactなど）とつなげてみる（そもそもレポジトリ名にnextを含んでいたので繋げようと思ったのですが、記事が長すぎてしまったので次回以降やりたいと思います。）

参考

go-ginでサクッとRESTAPIを構築する

golang,docker,mysqlの環境をherokuにデプロイする