GolangでAPIを開発する方法まとめ【Docker・Gin・Nginx・MySQL・Postman・Actions】

# Nginxのバージョンは軽量版の「alpine」
FROM nginx:alpine

# インクルード用のディレクトリ内を削除
RUN rm -f /etc/nginx/conf.d/*

# Nginxの設定ファイルをコンテナにコピー
ADD ./nginx/nginx.conf /etc/nginx/conf.d/default.conf

# ビルド完了後にNginxを起動
CMD /usr/sbin/nginx -g 'daemon off;' -c /etc/nginx/nginx.conf

server {
  # ポート番号
  listen 80;

  location / {
    # apiの部分はdocker-compose.ymlのサービス名
    proxy_pass http://api:3001;
  }
}

# 2023年3月時点の最新版goの軽量版「alpine」
FROM golang:1.20.2-alpine

# インストール可能なパッケージ一覧の更新
RUN apk update && \
    apk upgrade && \
    # パッケージのインストール（--no-cacheでキャッシュ削除）
    apk add --no-cache \
            git \
            gcc \
            musl-dev

# 作業ディレクトリの設定
WORKDIR /go/src

package main

import (
  // Ginをインポート
  "github.com/gin-gonic/gin"
)

funcmain() {
  router := gin.Default()

  // JSON形式で「"message": "Hello World"」を出力するAPI
  router.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "Hello World",
    })
  })

  router.Run(":3001")
}

version: '3'
  services:
    # APIに関する設定
    api:
      container_name: go_sample_api
      build:
        context: .
        dockerfile: ./src/docker/dev/Dockerfile
      env_file:
        - ./.env
      command: go run main.go
      volumes:
        - ./src:/go/src
      tty: true
      stdin_open: true
      ports:
        - "3001:3001"
    # Webサーバーに関する設定
    web:
      container_name: go_sample_web
      build:
        context: .
        dockerfile: ./nginx/Dockerfile
      volumes:
        - ./nginx/log:/var/log/nginx
      ports:
        - "80:80"
      depends_on:
        - api

# 2023年3月時点の最新版goの軽量版「alpine」
FROM golang:1.20.2-alpine

# ホットリロード用にAirをインストール
RUN go install github.com/cosmtrek/air@latest

# インストール可能なパッケージ一覧の更新
RUN apk update && \
    apk upgrade && \
    # パッケージのインストール（--no-cacheでキャッシュ削除）
    apk add --no-cache \
            git \
            gcc \
            musl-dev

# 作業ディレクトリの設定
WORKDIR /go/src

version: '3'
  services:
    # APIに関する設定
    api:
      container_name: go_sample_api
      build:
        context: .
        dockerfile: ./src/docker/dev/Dockerfile
      env_file:
        - ./.env
      command: air -c .air.toml
      volumes:
        - ./src:/go/src
      tty: true
      stdin_open: true
      ports:
        - "3001:3001"
    # Webサーバーに関する設定
    web:
      container_name: go_sample_web
      build:
        context: .
        dockerfile: ./nginx/Dockerfile
      volumes:
        - ./nginx/log:/var/log/nginx
      ports:
        - "80:80"
      depends_on:
        - api

package main

import (
  // Ginをインポート
  "github.com/gin-gonic/gin"
)

funcmain() {
  router := gin.Default()

  // JSON形式で「"message": "Hello World"」を出力するAPI
  router.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "Hello World !!",
    })
  })

  router.Run(":3001")
}

package controller

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

func Index(c *gin.Context) {
  c.JSON(200, gin.H{
    "message": "Hello World Index !!",
  })
}

package router

import (
  "github.com/gin-gonic/gin"
  "go_sample/controller"
)

func Init() {
  // routerの初期化
  router := gin.Default()

  // routerの設定
  router.GET("/", controller.Index)

  // routerを起動
  router.Run(":3001")
}

package main

import (
  "go_sample/router"
)

func main() {
  // routerの初期化
  router.Init()
}

db:
  type: "mysql"
  host: "db"
  port: 3306
  charset: "utf8mb4"
  parseTime: true
  loc: "Local"
migrate:
  filePath: "file://database/migrate"

package config

import (
  "fmt"
  "os"
  "github.com/spf13/viper"
  "github.com/fsnotify/fsnotify"
)

// config設定の構造体
type Config struct {
  Env string
  Tz string
  Db Db `yml:db`
  Migrate Migrate `yml:migrate`
}

type Db struct {
  Type string `yml:type`
  Host string `yml:host`
  Port int `yml:port`
  Charset string `yml:charset`
  ParseTime bool `yml:parseTime`
  Loc string `yml:loc`
  Database string
  User string
  Password string
}

type Migrate struct {
  FilePath string `yml:filePath`
}

var cfg *Config

func Init() {
  // viperの初期設定
  viper.SetConfigName("config_" + fmt.Sprintf("%s", os.Getenv("ENV")))
  viper.SetConfigType("yml")
  viper.AddConfigPath("config/")

  // configファイル更新時に再読み込み
  viper.WatchConfig()
  viper.OnConfigChange(func(e fsnotify.Event) {
    fmt.Println("Config file changed:", e.Name)
    viper.Unmarshal(&cfg)
  })

  // configファイルの読み込み
  err := viper.ReadInConfig()
  if err != nil {
    panic(err)
  }

  // 読み込んだデータを変数cfgに設定
  err = viper.Unmarshal(&cfg)
  if err != nil {
    panic(err)
  }

  // 環境変数の値を変数cfgに設定
  cfg.Env = os.Getenv("ENV")
  cfg.Tz = os.Getenv("TZ")
  cfg.Db.Database = os.Getenv("MYSQL_DATABASE")
  cfg.Db.User = os.Getenv("MYSQL_USER")
  cfg.Db.Password = os.Getenv("MYSQL_PASSWORD")
}

func GetConfig() *Config {
  return cfg
}

package main

import (
  "go_sample/config"
  "go_sample/router"
)

func main() {
  // configの初期化
  config.Init()

  // routerの初期化
  router.Init()
}

package controller

import (
  "github.com/gin-gonic/gin"
  "go_sample/config"
)

func ConfigIndex(c *gin.Context) {
  // config設定を取得
  cfg := config.GetConfig()

  c.JSON(200, gin.H{
    "ENV": cfg.Env,
    "Tz": cfg.Tz,
    "DB.Type": cfg.Db.Type,
    "DB.Host": cfg.Db.Host,
    "DB.Port": cfg.Db.Port,
    "DB.Charset": cfg.Db.Charset,
    "DB.ParseTime": cfg.Db.ParseTime,
    "DB.Loc": cfg.Db.Loc,
    "DB.Database": cfg.Db.Database,
    "DB.User": cfg.Db.User,
  })
}

package router

import (
  "github.com/gin-gonic/gin"
  "go_sample/controller"
)

func Init() {
  // routerの初期化
  router := gin.Default()

  // routerの設定
  router.GET("/", controller.Index)

  // APIの設定
  apiV1 := router.Group("/api/v1")
  apiV1.GET("/config", controller.ConfigIndex)

  // routerを起動
  router.Run(":3001")
}

# 2023年3月時点の最新版goの軽量版「alpine」
FROM golang:1.20.2-alpine

# ホットリロード用にAirをインストール
RUN go install github.com/cosmtrek/air@latest

# マイグレーション用にglang-migrate（MySQL）をインストール
RUN go install -tags mysql github.com/golang-migrate/migrate/v4/cmd/migrate@latest

# インストール可能なパッケージ一覧の更新
RUN apk update && \
    apk upgrade && \
    # パッケージのインストール（--no-cacheでキャッシュ削除）
    apk add --no-cache \
            git \
            gcc \
            musl-dev

# 作業ディレクトリの設定
WORKDIR /go/src

version: '3'
  services:
    # APIに関する設定
    api:
      container_name: go_sample_api
      build:
        context: .
        dockerfile: ./src/docker/dev/Dockerfile
      env_file:
        - ./.env
      command: air -c .air.toml
      volumes:
        - ./src:/go/src
      tty: true
      stdin_open: true
      ports:
        - "3001:3001"
      depends_on:
        - db
    # Webサーバーに関する設定
    web:
      container_name: go_sample_web
      build:
        context: .
        dockerfile: ./nginx/Dockerfile
      volumes:
        - ./nginx/log:/var/log/nginx
      ports:
        - "80:80"
      depends_on:
        - api
    # DBに関する設定
    db:
      container_name: go_sample_db
      image: mysql:8.0.32
      env_file:
        - ./.env
      ports:
        - 3306:3306
      volumes:
        - ./tmp/db:/var/lib/mysql

package main

import (
  "go_sample/config"
  "go_sample/database"
  "go_sample/router"
)

func main() {
  // configの初期化
  config.Init()

  // DBの初期化
  database.Init()
  defer database.Close()

  // routerの初期化
  router.Init()
}

DROP TABLE IF EXISTS users;

package model

import (
  "time"
  "go_sample/database"
  "errors"
)

// ユーザー情報の構造体
// usersテーブルのカラム名でjson出力するため、各項目に「`json:""`」を設定します。
type User struct {
  Id        int        `json:"id"`
  Uid       string     `json:"uid"`
  Name      string     `json:"name"`
  Email     string     `json:"email"`
  CreatedAt time.Time  `json:"created_at"`
  UpdatedAt time.Time  `json:"updated_at"`
  DeletedAt *time.Time `json:"deleted_at"`
}

// DBからusersテーブルの全レコードを取得
func GetUsersAll() (*[]User, error) {
  db := database.GetDB()

  var users *[]User
  result := db.Find(&users)
  if result.Error != nil {
    return nil, result.Error
  } else if result.RowsAffected == 0 {
    return nil, errors.New("users not registerd")
  }

  return users, nil
}

package controller

import (
  "github.com/gin-gonic/gin"
  "go_sample/model"
  "net/http"
)

// ユーザー一覧をJSON形式で出力
func UsersIndex(c *gin.Context) {
  users, err := model.GetUsersAll()
  if err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  c.JSON(http.StatusOK, users)
}

package router

import (
  "github.com/gin-gonic/gin"
  "go_sample/controller"
)

func Init() {
  // routerの初期化
  router := gin.Default()

  // routerの設定
  router.GET("/", controller.Index)

  // APIの設定
  apiV1 := router.Group("/api/v1")
  apiV1.GET("/config", controller.ConfigIndex)
  apiV1.GET("/users", controller.UsersIndex)

  // routerを起動
  router.Run(":3001")
}

package seed

import (
  "time"
  "go_sample/model"
  "gorm.io/gorm"
)

func UserSeeds(db *gorm.DB) error {
  // １件目のデータ
  user1 :=  model.User{
              Uid:       "uid:go_sample_1",
              Name:      "Sample_User_1",
              Email:     "sample1@example.com",
              CreatedAt: time.Now(),
              UpdatedAt: time.Now(),
            }
  if err := db.Create(&user1).Error; err != nil {
    return err
  }

  // ２件目のデータ
  user2 :=  model.User{
              Uid:       "uid:go_sample_2",
              Name:      "Sample_User_2",
              Email:     "sample2@example.com",
              CreatedAt: time.Now(),
              UpdatedAt: time.Now(),
            }
  if err := db.Create(&user2).Error; err != nil {
    return err
  }
  return nil
}

package main

import (
  "fmt"
  "go_sample/config"
  "go_sample/database"
  "go_sample/seed"
)

func main() {
  // Configの初期化
  config.Init()

  // DBの初期化
  database.Init()
  defer database.Close()

  // DBの取得
  db := database.GetDB()

  // seedの実行
  err := seed.UserSeeds(db)
  if err != nil {
    panic(err)
  }

  fmt.Println("Execution user_seeds.go !!")
}

package main

import (
  "fmt"
  "go_sample/config"
  "go_sample/database"
)

func main() {
  // Configの初期化
  config.Init()

  // DBの初期化
  database.Init()
  defer database.Close()

  // mの取得
  m := database.GetM()

  // マイグレーションのDownコマンド実行
  err := m.Down()
  if err != nil {
    panic(err)
  }

  fmt.Println("Execution m.Down() !!")
}

package model

import (
  "time"
  "go_sample/database"
  "errors"
)

// ユーザー情報の構造体
// usersテーブルのカラム名でjson出力するため、各項目に「`json:""`」を設定します。
type User struct {
  Id        int        `json:"id"`
  Uid       string     `json:"uid"`
  Name      string     `json:"name"`
  Email     string     `json:"email"`
  CreatedAt time.Time  `json:"created_at"`
  UpdatedAt time.Time  `json:"updated_at"`
  DeletedAt *time.Time `json:"deleted_at"`
}

// DBからusersテーブルの全レコードを取得
func GetUsersAll() (*[]User, error) {
  db := database.GetDB()

  var users *[]User
  result := db.Find(&users)
  if result.Error != nil {
    return nil, result.Error
  } else if result.RowsAffected == 0 {
    return nil, errors.New("users not registerd")
  }

  return users, nil
}

// ユーザーを作成
func CreateUser(r User) error {
  db := database.GetDB()

  // トランザクションの開始
  tx := db.Begin()

  user := User{
            Uid:       r.Uid,
            Name:      r.Name,
            Email:     r.Email,
            CreatedAt: time.Now(),
            UpdatedAt: time.Now(),
          }

  if err := tx.Create(&user).Error; err != nil {
    // エラーの場合はロールバック
    tx.Rollback()
    return err
  }
  // コミットしてトランザクションを終了
  tx.Commit()

  return nil
}

// 対象のユーザーを１件取得
func GetUser(id int) (*User, error) {
  db := database.GetDB()

  var user *User
  result := db.First(&user, id)
  if result.Error != nil {
    return nil, result.Error
  }

  return user, nil
}

// ユーザー情報を更新
func UpdateUser(id int, r User) error {
  db := database.GetDB()

  // トランザクションの開始
  tx := db.Begin()

  // nil値項目の更新なし、updated_atの更新あり
  err := tx.Updates(&User{
              Id: id,
              Name: r.Name,
              Email: r.Email,
            }).Error
  if err != nil {
    // エラーの場合はロールバック
    tx.Rollback()
    return err
  }
  // コミットしてトランザクションを終了
  tx.Commit()

  return nil
}

// ユーザー削除
func DeleteUser(id int) error {
  db := database.GetDB()

  // トランザクションの開始
  tx := db.Begin()

  // 対象ユーザーを物理削除
  if err := tx.Delete(&User{}, id).Error; err != nil {
    // エラーの場合はロールバック
    tx.Rollback()
    return err
  }
  // コミットしてトランザクションを終了
  tx.Commit()

  return nil
}

package controller

import (
  "github.com/gin-gonic/gin"
  "go_sample/model"
  "net/http"
  "strconv"
)

// ユーザー一覧をJSON形式で出力
func UsersIndex(c *gin.Context) {
  users, err := model.GetUsersAll()
  if err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  c.JSON(http.StatusOK, users)
}

// ユーザーを作成
func UserCreate(c *gin.Context) {
  // リクエストボディをバインド
  var req model.User
  if err := c.ShouldBindJSON(&req); err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  if err := model.CreateUser(req); err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  c.JSON(http.StatusOK, req)
}

// ユーザー１件をJSON形式で出力
func UserShow(c *gin.Context) {
  // パラメータ「:id」を数値変換
  id, err := strconv.Atoi(c.Param("id"))
  if err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  user, err := model.GetUser(id)
  if err != nil {
    c.JSON(http.StatusNotFound, gin.H{
      "message": err.Error(),
    })
    return
  }

  c.JSON(http.StatusOK, user)
}

// ユーザー情報を更新
func UserUpdate(c *gin.Context) {
  // パラメータ「:id」を数値変換
  id, err := strconv.Atoi(c.Param("id"))
  if err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  // リクエストボディをバインド
  var req model.User
  if err := c.ShouldBindJSON(&req); err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  if err := model.UpdateUser(id, req); err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  c.JSON(http.StatusOK, req)
}

// ユーザーを削除
func UserDelete(c *gin.Context) {
  // パラメータ「:id」を数値変換
  id, err := strconv.Atoi(c.Param("id"))
  if err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  if err := model.DeleteUser(id); err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "error": err.Error(),
    })
    return
  }

  c.JSON(http.StatusOK, gin.H{
    "message": "user(" + strconv.Itoa(id) + ") is deleted",
  })
}

package router

import (
  "github.com/gin-gonic/gin"
  "go_sample/controller"
)

func Init() {
  // routerの初期化
  router := gin.Default()

  // routerの設定
  router.GET("/", controller.Index)

  // APIの設定
  apiV1 := router.Group("/api/v1")
  apiV1.GET("/config", controller.ConfigIndex)
  apiV1.GET("/users", controller.UsersIndex)

  // ユーザーのCRUD用APIを追加
  apiV1.POST("/users", controller.UserCreate)
  apiV1.GET("/users/:id", controller.UserShow)
  apiV1.PATCH("/users/:id", controller.UserUpdate)
  apiV1.DELETE("/users/:id", controller.UserDelete)

  // routerを起動
  router.Run(":3001")
}

// リクエスト実行前にユーザー一覧からデータ件数を取得
pm.sendRequest("http://localhost/api/v1/users", function (err, response) {
    const　beforeDataCount = response.json().length
    pm.variables.set("beforeDataCount", beforeDataCount);
});

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

// リクエスト実行後にユーザー一覧からデータ件数を取得し、リクエスト実行前のデータ件数と比較
pm.sendRequest("http://localhost/api/v1/users", function (err, response) {
    const beforeDataCount = pm.variables.get("beforeDataCount");
    const afterDataCount = response.json().length;

    pm.test("ユーザーのデータ件数が１件増加", function () {
        pm.expect(afterDataCount).to.eql(beforeDataCount + 1);
    });
});

// リクエスト実行前にユーザー一覧から取得した最後のデータのidを変数「paramId」に設定
pm.sendRequest("http://localhost/api/v1/users", function (err, response) {
    const　lastUserData = response.json().pop()
    pm.variables.set("paramId", lastUserData.id);
});

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

// パラメータ「id」が「paramId」のユーザーのレスポンスの結果を確認
pm.test("id == paramId", function () {
    const paramId = pm.variables.get("paramId");
    pm.expect(pm.response.json().id).to.eql(paramId);
});
pm.test("uid == uid:test3", function () {
    pm.expect(pm.response.json().uid).to.eql("uid:test3");
});
pm.test("name == test3", function () {
    pm.expect(pm.response.json().name).to.eql("test3");
});
pm.test("email == test3@example.com", function () {
    pm.expect(pm.response.json().email).to.eql("test3@example.com");
});
pm.test("created_at is not null", function () {
    pm.expect(pm.response.json().created_at).not.eql(null);
});
pm.test("updated_at is not null", function () {
    pm.expect(pm.response.json().updated_at).not.eql(null);
});
pm.test("deleted_at is null", function () {
    pm.expect(pm.response.json().deleted_at).to.eql(null);
});

// リクエスト実行前にユーザー一覧から取得した最後のデータを変数に設定
pm.sendRequest("http://localhost/api/v1/users", function (err, response) {
    const　lastUserData = response.json().pop()
    pm.variables.set("paramId", lastUserData.id);
    pm.variables.set("beforeUser", lastUserData);

    // updated_atの更新を確認するため1秒だけ待機させる
    const sleep = waitTime => new Promise( resolve => setTimeout(resolve, waitTime) );
    sleep(1000);
});

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

// リクエスト実行後にユーザー一覧から取得した最後のデータとリクエスト実行前のデータを比較
pm.sendRequest("http://localhost/api/v1/users", function (err, response) {
    const beforeUser = pm.variables.get("beforeUser");
    const afterUser = response.json().pop()

    pm.test("リクエスト実行前後でidが更新されていないこと", function () {
        pm.expect(afterUser.id).to.eql(beforeUser.id);
    });
    pm.test("リクエスト実行前後でuidが更新されていないこと", function () {
        pm.expect(afterUser.uid).to.eql(beforeUser.uid);
    });
    pm.test("リクエスト実行後にnameが「Sample_User_3」更新されていること", function () {
        pm.expect(afterUser.name).to.eql("Sample_User_3");
    });
    pm.test("リクエスト実行前後でemailが更新されていないこと", function () {
        pm.expect(afterUser.email).to.eql(beforeUser.email);
    });
    pm.test("リクエスト実行後はupdated_atが更新されていること", function () {
        pm.expect(afterUser.updated_at　> beforeUser.updated_at).to.eql(true);
    });
    pm.test("リクエスト実行後にdeleted_atがnullであること", function () {
        pm.expect(afterUser.deleted_at).to.eql(null);
    });
});

// リクエスト実行前にユーザー一覧からデータ件数と最後のデータを取得し、変数に設定
pm.sendRequest("http://localhost/api/v1/users", function (err, response) {
    const　beforeDataCount = response.json().length
    const　lastUserData = response.json().pop()

    pm.variables.set("beforeDataCount", beforeDataCount);
    pm.variables.set("paramId", lastUserData.id);
});

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

// リクエスト実行後にユーザー一覧からデータ件数を取得し、リクエスト実行前のデータ件数と比較
pm.sendRequest("http://localhost/api/v1/users", function (err, response) {
    const beforeDataCount = pm.variables.get("beforeDataCount");
    const afterDataCount = response.json().length;

    pm.test("ユーザーのデータ件数が１件減少", function () {
        pm.expect(afterDataCount).to.eql(beforeDataCount - 1);
    });
});

name: go_sample github actions

on:
  push:

jobs:
  test:
    name: Run Postman Api Tests
    runs-on: ubuntu-latest
    # 使用する環境変数定義の指定
    environment: dev
    # 処理の実行
    steps:
      - name: Checkout
        uses: actions/checkout@v3

      - name: Postman CLI install
        run: curl -o- "https://dl-cli.pstmn.io/install/linux64.sh" | sh

      # .envの作成
      - name: Create .env
        run: touch .env

      - name: Add environment variable to .env
        run: |
          echo ENV=${{secrets.ENV}} >> .env
          echo TZ=${{secrets.TZ}} >> .env
          echo MYSQL_DATABASE=${{secrets.MYSQL_DATABASE}} >> .env
          echo MYSQL_USER=${{secrets.MYSQL_USER}} >> .env
          echo MYSQL_PASSWORD=${{secrets.MYSQL_PASSWORD}} >> .env
          echo MYSQL_ROOT_PASSWORD=${{secrets.MYSQL_ROOT_PASSWORD}} >> .env

      # コンテナのビルドと起動
      - name: docker compose build --no-cache
        run: docker compose build --no-cache

      - name: docker compose up -d
        run: docker compose up -d

      # コンテナが立ち上がり切るまでの待機処理
      - name: sleeep 30
        run: sleep 30

      # seederの実行
      - name: docker compose exec api go run cmd/seeder.go
        run: docker compose exec api go run cmd/seeder.go

      # テストの実行
      - name: postman collection run
        run: postman collection run src/postman/go_sample_collection.postman_collection.json