Docker 環境と Go Gin で最小 API を実装する：MongoDB

Last updated at 2024-08-11Posted at 2024-08-11

Docker 環境と Go Gin で最小 API を実装する：MongoDB

こんにちは、@studio_meowtoon です。今回は、WSL の Ubuntu 24.04 で Go Gin Web アプリケーションを作成し、最小限の REST API を実装する方法を紹介します。

目的

Windows 11 の Linux でクラウド開発します。

こちらから記事の一覧がご覧いただけます。

実現すること

ローカル環境の Ubuntu の Docker 環境で、Dockerfile からビルドした Go Gin サービスのカスタムコンテナーと MongoDB データベースコンテナーを起動します。

ネイティブイメージ形式のアプリをコンテナーとして起動

実行環境

要素	概要
terminal	ターミナル
Ubuntu	OS
Docker	コンテナー実行環境

API サービスコンテナー

要素	概要
api-todo-gin	API サービスカスタムコンテナー
app	ネイティブイメージアプリケーション
gin	Web サーバー機能を含む

データベースコンテナー

要素	概要
mongodb-todo	データベースコンテナー
mongodb	DB サーバー
db_todo	データベース

技術トピック

Gin とは？

こちらを展開してご覧いただけます。

Gin (ジン)

Gin は、Go 言語向けの軽量で高速な Web フレームワークです。

キーワード	内容
高速性	Gin は非常に高速で軽量なフレームワークであり、HTTP ルーティングやハンドリングの性能が優れています。これにより、高負荷なアプリケーションでも高い処理能力を発揮します。
最小構成	Gin は最小限の機能を提供するため、不要な機能やコードが含まれません。これにより、アプリケーションのサイズや起動時間を最小限に抑えることができます。
パフォーマンス重視	Gin はルーティングやミドルウェアの処理において、最適化されたアプローチを採用しています。これにより、アプリケーション全体のパフォーマンスが向上します。
豊富なミドルウェア	Gin はミドルウェアのサポートを提供し、リクエスト/レスポンスの前後で機能を拡張できます。認証、ロギング、エラーハンドリングなど、多くのミドルウェアが用意されています。
学習しやすさ	シンプルなルーティングとクリーンなコード構造により、新しい開発者が迅速に学び始め、プロジェクトに参加することが容易です。
活発なコミュニティ	Gin は人気があり、アクティブなコミュニティが存在します。ドキュメントやリソースが豊富で、問題を解決するためのサポートが得られます。

開発環境

Windows 11 Home 23H2 を使用しています。

WSL の Ubuntu を操作しますので macOS の方も参考にして頂けます。

WSL (Microsoft Store アプリ版) ※ こちらの関連記事からインストール方法をご確認いただけます

> wsl --version
WSL バージョン: 2.2.4.0
カーネル バージョン: 5.15.153.1-2
WSLg バージョン: 1.0.61

Ubuntu ※ こちらの関連記事からインストール方法をご確認いただけます

$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 24.04 LTS
Release:        24.04
Codename:       noble

Docker ※ こちらの関連記事からインストール方法をご確認いただけます

$ docker --version
Docker version 27.0.3, build 7d4bcd8

この記事では基本的に Ubuntu のターミナルで操作を行います。Vim を使用してコピペする方法をはじめて学ぶ人のために、以下の記事で手順を紹介しています。ぜひ挑戦してみてください。

作成する REST API の仕様

エンドポイント	HTTPメソッド	説明	リクエストBody	レスポンスBody
/todos	GET	すべての ToDo アイテムを取得します。	None	ToDo アイテムの配列
/todos/complete	GET	完了した ToDo アイテムを取得します。	None	ToDo アイテムの配列
/todos/{id}	GET	ID で ToDo アイテムを取得します。	None	ToDo アイテム
/todos	POST	新しい ToDo アイテムを追加します。	ToDo アイテム	ToDo アイテム
/todos/{id}	PUT	既存の ToDo アイテムを更新します。	ToDo アイテム	None
/todos/{id}	DELETE	ID で ToDo アイテムを削除します。	None	None

データベースコンテナーの起動

こちらの記事で、ToDo アプリ用の NoSQL データベースを作成し、Docker コンテナーとして起動する手順をご確認いただけます。

データベースコンテナーが起動していることを確認します。

$ docker ps
CONTAINER ID   IMAGE        COMMAND                   CREATED          STATUS          PORTS                                           NAMES
6b411c62bc95   mongo-base   "docker-entrypoint.s…"   41 minutes ago   Up 41 minutes   0.0.0.0:27017->27017/tcp, :::27017->27017/tcp   mongodb-todo

コンテナー間通信するために net-todo という Docker ネットワークをあらかじめ作成しています。ご注意ください。

REST API を実装する手順

Go 言語のインストール

Go 言語をインストールします。

$ sudo apt update
$ sudo apt install golang

Go 言語をアンインストール場合には以下のコマンドを実行します。

$ sudo apt remove --purge golang-go golang-*
$ sudo apt autoremove --purge
$ sudo apt clean

バージョンを確認します。

$ go version
go version go1.22.2 linux/amd64

プロジェクトの作成

プロジェクトフォルダーを作成します。
※ ~/tmp/restapi-gin をプロジェクトフォルダーとします。

$ mkdir -p ~/tmp/restapi-gin
$ cd ~/tmp/restapi-gin

モデルファイルの作成

このシリーズの記事で、RDBMS と NoSQL の両方で同じ API 操作を行います。そのため、ID フィールドは数値型ではなく文字列として定義しています。統一性を保ちつつ異なるデータストアで動作することを目指しています。ご了承ください。

todo.go ファイルを作成します。

$ mkdir -p model
$ vim model/todo.go

model/todo.go

package model

import (
    "encoding/json"
    "log"
    "os"
    "time"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

// データベース接続に接続する関数
func ConnectDb() (*mongo.Collection, error) {
    var op *options.ClientOptions = options.Client().ApplyURI("mongodb://" +
        os.Getenv("DB_USER") + ":" +
        os.Getenv("DB_PASSWORD") + "@" +
        os.Getenv("DB_HOST") + ":" +
        os.Getenv("DB_PORT"),
    )
    cli, err := mongo.Connect(nil, op) // *mongo.Client, error
    if err != nil {
        log.Fatal(err)
        return nil, err
    }
    var co *mongo.Collection = cli.Database(os.Getenv("DB_NAME")).Collection("todos")
    return co, nil
}

// ToDo エンティティを表す構造体
type Todo struct {
    Id            primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
    Content       string             `json:"content,omitempty" bson:"content,omitempty"`
    CreatedDate   time.Time          `json:"created_date,omitempty" bson:"created_date,omitempty"`
    CompletedDate *time.Time         `json:"completed_date,omitempty" bson:"completed_date,omitempty"`
}

// JSON マーシャリング時に呼ばれる完了日に null を挿入するためのメソッド
func (t *Todo) MarshalJSON() ([]byte, error) {
    type Alias Todo
    if t.CompletedDate == nil {
        return json.Marshal(&struct {
            *Alias
            CompletedDate *time.Time `json:"completed_date"`
        }{
            Alias:         (*Alias)(t),
            CompletedDate: nil,
        })
    }
    return json.Marshal((*Alias)(t))
}

// ドキュメントID を "_id" に変換するメソッド
func (t *Todo) ToMongo() bson.M {
    return bson.M{
        "_id":            t.Id,
        "content":        t.Content,
        "created_date":   t.CreatedDate,
        "completed_date": nil,
    }
}

// ドキュメントID を "id" に変換するメソッド
func (t *Todo) FromMongo() bson.M {
    return bson.M{
        "id":             t.Id,
        "content":        t.Content,
        "created_date":   t.CreatedDate,
        "completed_date": nil,
    }
}

アプリケーションファイルの作成

main.go ファイルを作成します。

$ vim main.go

ファイルの内容

main.go

package main

import (
    "errors"
    "log"
    "os"
    "time"

    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"

    "api-todo/model"
)

func main() {
    // gin のデフォルトエンジンを作成
    var r *gin.Engine = gin.Default()

    // データベース接続・コレクション取得
    co, err := model.ConnectDb() // *mongo.Collection, error
    if err != nil {
        log.Fatal(err)
    }

    // ミドルウェアにコレクションを設定
    r.Use(setCollection("todos", co))

    // CORS 設定：適切に修正してください。
    var conf cors.Config = cors.DefaultConfig()
    conf.AllowAllOrigins = true
    conf.AllowCredentials = true
    conf.AllowMethods = []string{"GET", "POST", "PUT", "DELETE"}
    conf.AllowHeaders = []string{"Origin", "Authorization", "Content-Type"}
    r.Use(cors.New(conf))

    // ToDo アプリケーションの API エンドポイント定義
    r.GET("/todos", getAllTodos)
    r.GET("/todos/complete", getCompletedTodos)
    r.GET("/todos/:id", getTodo)
    r.POST("/todos", createTodo)
    r.PUT("/todos/:id", updateTodo)
    r.DELETE("/todos/:id", deleteTodo)

    // API_PORT 環境変数からポート番号を取得
    var port string = os.Getenv("API_PORT")
    if port == "" {
        port = "5000"
    }

    // アプリケーションを指定されたポートで起動
    err = r.Run(":" + port)
    if err != nil {
        log.Fatal(err)
    }
}

// すべての ToDo アイテムを取得します。
func getAllTodos(ctx *gin.Context) {
    var todos []model.Todo
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    cursor, err := co.Find(nil, bson.M{}) // *mongo.Cursor, error
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    defer cursor.Close(nil)
    for cursor.Next(nil) {
        var todo model.Todo
        err = cursor.Decode(&todo)
        if handleError(ctx, 500, "Internal Server Error", err) {
            return
        }
        todos = append(todos, todo)
    }
    ctx.JSON(200, todos)
}

// 完了した ToDo アイテムを取得します。
func getCompletedTodos(ctx *gin.Context) {
    var filter primitive.M = bson.M{"completed_date": bson.M{"$ne": nil}}
    var todos []model.Todo
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    cursor, err := co.Find(nil, filter) // *mongo.Cursor, error
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    defer cursor.Close(nil)
    for cursor.Next(nil) {
        var todo model.Todo
        err = cursor.Decode(&todo)
        if handleError(ctx, 500, "Internal Server Error", err) {
            return
        }
        todos = append(todos, todo)
    }
    ctx.JSON(200, todos)
}

// ID で ToDo アイテムを取得します。
func getTodo(ctx *gin.Context) {
    var id string = ctx.Param("id")
    var todo model.Todo
    objId, err := primitive.ObjectIDFromHex(id) // primitive.ObjectID, error
    if handleError(ctx, 400, "Invalid ID", err) {
        return
    }
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    err = co.FindOne(nil, bson.M{"_id": objId}).Decode(&todo)
    if handleError(ctx, 404, "Todo not found", err) {
        return
    }
    ctx.JSON(200, todo)
}

// 新しい ToDo アイテムを追加します。
func createTodo(ctx *gin.Context) {
    var create model.Todo
    err := ctx.BindJSON(&create)
    if handleError(ctx, 400, "Invalid input", err) {
        return
    }
    create.Id = primitive.NewObjectID()
    create.CreatedDate = time.Now()
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    _, err = co.InsertOne(nil, create.ToMongo())
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    ctx.JSON(201, create.FromMongo())
}

// 既存の ToDo アイテムを更新します。
func updateTodo(ctx *gin.Context) {
    var id string = ctx.Param("id")
    objId, err := primitive.ObjectIDFromHex(id) // primitive.ObjectID, error
    if handleError(ctx, 400, "Invalid ID", err) {
        return
    }
    var update model.Todo
    err = ctx.BindJSON(&update)
    if handleError(ctx, 400, "Invalid input", err) {
        return
    }
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    var exist model.Todo
    err = co.FindOne(nil, bson.M{"_id": objId}).Decode(&exist)
    if handleError(ctx, 404, "Todo not found", err) {
        return
    }
    update.Id = exist.Id
    update.CreatedDate = exist.CreatedDate
    _, err = co.ReplaceOne(nil, bson.M{"_id": objId}, update)
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    ctx.JSON(200, update)
}

// ID で ToDo アイテムを削除します。
func deleteTodo(ctx *gin.Context) {
    var id string = ctx.Param("id")
    objId, err := primitive.ObjectIDFromHex(id) // primitive.ObjectID, error
    if handleError(ctx, 400, "Invalid ID", err) {
        return
    }
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    _, err = co.DeleteOne(nil, bson.M{"_id": objId})
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    ctx.JSON(204, nil)
}

// gin のコンテキストにコレクションを保持する関数
func setCollection(name string, co *mongo.Collection) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Set(name, co)
        c.Next()
    }
}

// gin のコンテキストにコレクションを取得する関数
func getCollection(name string, ctx *gin.Context) (*mongo.Collection, bool) {
    value, exists := ctx.Get(name) // any, bool
    if !exists {
        handleError(ctx, 500, "Internal Server Error", errors.New("Collection not found in context."))
        return nil, false
    }
    co, ok := value.(*mongo.Collection) // *mongo.Collection, bool
    if !ok {
        handleError(ctx, 500, "Internal Server Error", errors.New("Failed to cast collection."))
        return nil, false
    }
    return co, true
}

// カスタムのエラーハンドリング関数
func handleError(ctx *gin.Context, code int, msg string, err error) bool {
    if err != nil {
        log.Println(msg + ": " + err.Error())
        ctx.JSON(code, gin.H{"error": "An internal server error occurred."})
        return true
    }
    return false
}

パッケージの追加

プロジェクトを初期化します。

$ go mod init api-todo

パッケージをインストールします。

$ go get -u \
    github.com/gin-gonic/gin \
    github.com/gin-contrib/cors \
    go.mongodb.org/mongo-driver/bson \
    go.mongodb.org/mongo-driver/bson/primitive \
    go.mongodb.org/mongo-driver/mongo \
    go.mongodb.org/mongo-driver/mongo/options

バージョンを確認します。

$ go list -m github.com/gin-gonic/gin
github.com/gin-gonic/gin v1.10.0
$ go list -m github.com/gin-contrib/cors
github.com/gin-contrib/cors v1.7.2
$ go list -m go.mongodb.org/mongo-driver
go.mongodb.org/mongo-driver v1.16.1

アプリのビルドと起動

環境変数を作成します。

export DB_HOST=localhost
export DB_PORT=27017
export DB_NAME=db_todo
export DB_USER=root
export DB_PASSWORD=password

この環境変数が一時的なものであることに注意してください。

アプリを起動します。
※ アプリを停止するときは ctrl + C を押します。

$ export API_PORT=5000 && go run main.go

ここまでの手順で、Ubuntu でアプリを起動することができました。

アプリの動作確認

別ターミナルから curl コマンドで確認します。

必要な場合、jq をインストールします。

$ sudo apt update
$ sudo apt install jq

GET: /todos エンドポイントの動作確認

すべての ToDo アイテムを取得します。

$ curl -s http://localhost:5000/todos | jq '.'

レスポンス

[
// 省略
  {
    "id": "66b7f3866c2fb3b3a7149f4a",
    "content": "運動する",
    "created_date": "2024-08-10T23:11:02.524Z",
    "completed_date": "2024-08-10T23:11:02.524Z"
  },
  {
    "id": "66b7f3866c2fb3b3a7149f4b",
    "content": "本を読む",
    "created_date": "2024-08-10T23:11:02.524Z",
    "completed_date": null
  },
  {
    "id": "66b7f3866c2fb3b3a7149f4c",
    "content": "請求書を支払う",
    "created_date": "2024-08-10T23:11:02.524Z",
    "completed_date": null
  },
// 省略

すべての ToDo アイテムを取得できています。

GET: /todos/complete エンドポイントの動作確認

完了した ToDo アイテムを取得します。

$ curl -s http://localhost:5000/todos/complete | jq '.'

レスポンス

[
  {
    "id": "66b7f3866c2fb3b3a7149f48",
    "content": "食材を買う",
    "created_date": "2024-08-10T23:11:02.524Z",
    "completed_date": "2024-08-10T23:11:02.524Z"
  },
  {
    "id": "66b7f3866c2fb3b3a7149f49",
    "content": "報告書を仕上げる",
    "created_date": "2024-08-10T23:11:02.524Z",
    "completed_date": "2024-08-10T23:11:02.524Z"
  },
  {
    "id": "66b7f3866c2fb3b3a7149f4a",
    "content": "運動する",
    "created_date": "2024-08-10T23:11:02.524Z",
    "completed_date": "2024-08-10T23:11:02.524Z"
  }
]

完了した ToDo アイテムを取得できています。

GET: /todos/{id} エンドポイントの動作確認

ID で ToDo アイテムを取得します。

id: 66b7f3866c2fb3b3a7149f4f は、その都度適切な値を設定してください。

$ curl -s http://localhost:5000/todos/66b7f3866c2fb3b3a7149f4f | jq '.'

レスポンス

{
  "id": "66b7f3866c2fb3b3a7149f4f",
  "content": "コードを書く",
  "created_date": "2024-08-10T23:11:02.524Z"
}

ID で ToDo アイテムを取得できています。

POST: /todos エンドポイントの動作確認

新しい ToDo アイテムを追加します。

$ curl -s -X POST http://localhost:5000/todos \
    -H 'Content-Type: application/json; charset=utf-8' \
    -d \
'{
    "content": "昼寝をする"
}' | jq '.'

レスポンス

{
  "completed_date": null,
  "content": "昼寝をする",
  "created_date": "2024-08-11T09:56:51.377707042+09:00",
  "id": "66b80c5361708660bc0490fd"
}

新しい ToDo アイテムが追加できています。

PUT: /todos/{id} エンドポイントの動作確認

既存の ToDo アイテムを更新します。

id: 66b80c5361708660bc0490fd は、その都度適切な値を設定してください。

$ curl -s -X PUT http://localhost:5000/todos/66b80c5361708660bc0490fd \
    -H 'Content-Type: application/json; charset=utf-8' \
    -d \
'{
    "content": "窓を開ける"
}' | jq '.'

レスポンス

{
  "id": "66b80c5361708660bc0490fd",
  "content": "窓を開ける",
  "created_date": "2024-08-11T00:56:51.377Z"
}

ToDo アイテムが更新できています。

DELETE: /todos/{id} エンドポイントの動作確認

ID で ToDo アイテムを削除します。

id: 66b80c5361708660bc0490fd は、その都度適切な値を設定してください。

$ curl -s -X DELETE http://localhost:5000/todos/66b80c5361708660bc0490fd | jq '.'

レスポンス

※なし

レスポンスはありませんが、DB のコレクションを確認すると対象のレコードが削除されています。

ここまでの手順で、最小限の CRUD 操作を行う REST API をアプリに実装できました。

コンテナーイメージの作成

Dockerfile を作成します。

$ vim Dockerfile

ファイルの内容

Dockerfile

# build the app.
FROM golang:1.22 AS build-env

# set the working dir.
WORKDIR /app

# copy the go module dependency files.
COPY go.mod go.sum ./

# download the go module dependencies.
RUN go mod download

# copy the app source code.
COPY . .

# build the go app binary.
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app main.go

# set up the container.
FROM debian:12-slim

# set the working dir.
WORKDIR /app

# copy the built app binary from the build-env.
COPY --from=build-env /app/app ./app

# expose the port.
EXPOSE 5000

# command to run the app.
CMD ["./app"]

Docker デーモンを起動します。

$ sudo service docker start

Docker 環境をお持ちでない場合は、以下の関連記事から Docker Engine のインストール手順をご確認いただけます。

コンテナーイメージをビルドします。

$ docker build \
    --no-cache \
    --tag api-todo-gin:latest .

コンテナーイメージを確認します。

$ docker images | grep api-todo-gin
api-todo-gin    latest    077f0bad8f71   17 seconds ago   91.5MB

ここまでの手順で、ローカル環境の Docker にアプリのカスタムコンテナーイメージをビルドすることができました。

コンテナーを起動

ローカルでコンテナーを起動します。
※ コンテナーを停止するときは ctrl + C を押します。

コンテナー間通信するために net-todo という Docker ネットワークをあらかじめ作成しています。ご注意ください。

$ docker run --rm \
    --publish 5000:5000 \
    --name api-local \
    --net net-todo \
    --env DB_HOST=mongodb-todo \
    --env DB_PORT=27017 \
    --env DB_NAME=db_todo \
    --env DB_USER=root \
    --env DB_PASSWORD=password \
    api-todo-gin

ここまでの手順で、ローカル環境の Docker でアプリのカスタムコンテナーを起動することができました。

コンテナーの動作確認

別ターミナルから curl コマンドで確認します。
※ ID で ToDo アイテムを取得します。

id: 66b7f3866c2fb3b3a7149f4f は、その都度適切な値を設定してください。

$ curl -s http://localhost:5000/todos/66b7f3866c2fb3b3a7149f4f | jq '.'

レスポンス

{
  "id": "66b7f3866c2fb3b3a7149f4f",
  "content": "コードを書く",
  "created_date": "2024-08-10T23:11:02.524Z"
}

ここまでの手順で、ターミナルにレスポンスが表示され、JSON データを取得することができました。

コンテナーの状態を確認してみます。

$ docker ps
CONTAINER ID   IMAGE          COMMAND                   CREATED              STATUS              PORTS                                           NAMES
50f487b8daf8   api-todo-gin   "./app"                   About a minute ago   Up About a minute   0.0.0.0:5000->5000/tcp, :::5000->5000/tcp       api-local
6b411c62bc95   mongo-base     "docker-entrypoint.s…"   3 hours ago          Up 3 hours          0.0.0.0:27017->27017/tcp, :::27017->27017/tcp   mongodb-todo

コンテナーに接続

別ターミナルからコンテナーに接続します。

$ docker exec -it api-local /bin/bash

コンテナー接続後にディレクトリを確認します。
※ コンテナーから出るときは ctrl + D を押します。

# pwd
/app
# ls -lah
total 16M
drwxr-xr-x 1 root root 4.0K Aug 11 01:50 .
drwxr-xr-x 1 root root 4.0K Aug 11 02:00 ..
-rwxr-xr-x 1 root root  16M Aug 11 01:50 app

top コマンドで状況を確認します。

# apt update
# apt install procps
# top
top - 02:04:08 up  3:01,  0 user,  load average: 0.00, 0.04, 0.07
Tasks:   3 total,   1 running,   2 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.1 us,  0.1 sy,  0.0 ni, 99.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :  15949.2 total,  14549.9 free,   1145.5 used,    563.5 buff/cache
MiB Swap:   4096.0 total,   4096.0 free,      0.0 used.  14803.7 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
      1 root      20   0 1236044  11200   8308 S   0.3   0.1   0:00.08 app
     12 root      20   0    4188   3480   2972 S   0.0   0.0   0:00.02 bash
    203 root      20   0    8560   4568   2700 R   0.0   0.0   0:00.00 top

コンテナーの情報を表示してみます。

# cat /etc/*-release
PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
NAME="Debian GNU/Linux"
VERSION_ID="12"
VERSION="12 (bookworm)"
VERSION_CODENAME=bookworm
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"

このコンテナーは Debian GNU/Linux をベースに作成されています。つまり、Debian GNU/Linux と同じように扱うことができます。

おまけ：Swagger 装備

ライブラリの追加

swag コマンドをインストールします。

$ go install github.com/swaggo/swag/cmd/swag@latest
$ export PATH=$PATH:/home/$USER/go/bin

gin-swagger パッケージをインストールします。

$ go get -u github.com/swaggo/gin-swagger
$ go get -u github.com/swaggo/files

コードの修正

コードに以下の内容を追記します。

main.go ※一部分

import (
    // 省略
    "api-todo/docs"
    swaggerfiles "github.com/swaggo/files"
    ginSwagger "github.com/swaggo/gin-swagger"
    // 省略
)

func main() {
    // 省略

    // Swagger の設定
    docs.SwaggerInfo.Title = "Todo API"
    docs.SwaggerInfo.Version = "0.1.0"
    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))
    // 省略
}

// @Summary Get All Todos
// @Description すべての ToDo アイテムを取得します。
// @Tags todos
// @Accept json
// @Produce json
// @Success 200 {array} model.Todo
// @Router /todos [get]
func getAllTodos(ctx *gin.Context) {
    // 省略
}

// @Summary Get Completed Todos
// @Description 完了した ToDo アイテムを取得します。
// @Tags todos
// @Accept json
// @Produce json
// @Success 200 {array} model.Todo
// @Router /todos/complete [get]
func getCompletedTodos(ctx *gin.Context) {
    // 省略
}

// @Summary Get Todo
// @Description ID で ToDo アイテムを取得します。
// @Tags todos
// @Accept json
// @Produce json
// @Param id path string true "Todo ID"
// @Success 200 {object} model.Todo
// @Router /todos/{id} [get]
func getTodo(ctx *gin.Context) {
    // 省略
}

// @Summary Create Todo
// @Description 新しい ToDo アイテムを追加します。
// @Tags todos
// @Accept json
// @Produce json
// @Param todo body model.Todo true "Todo to create"
// @Success 201 {object} model.Todo
// @Router /todos [post]
func createTodo(ctx *gin.Context) {
    // 省略
}

// @Summary Update Todo
// @Description ToDo アイテムを更新します。
// @Tags todos
// @Accept json
// @Produce json
// @Param id path string true "Todo ID"
// @Param todo body model.Todo true "Todo to update"
// @Success 200 {object} model.Todo
// @Router /todos/{id} [put]
func updateTodo(ctx *gin.Context) {
    // 省略
}

// @Summary Delete Todo
// @Description ID で ToDo アイテムを削除します。
// @Tags todos
// @Accept json
// @Produce json
// @Param id path string true "Todo ID"
// @Success 204 {object} nil
// @Router /todos/{id} [delete]
func deleteTodo(ctx *gin.Context) {
    // 省略
}

コードの全体を表示する

main.go

package main

import (
    "errors"
    "log"
    "os"
    "time"

    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    swaggerfiles "github.com/swaggo/files"
    ginSwagger "github.com/swaggo/gin-swagger"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"

    "api-todo/model"
    "api-todo/docs"
)

func main() {
    // gin のデフォルトエンジンを作成
    var r *gin.Engine = gin.Default()

    // データベース接続・コレクション取得
    co, err := model.ConnectDb() // *mongo.Collection, error
    if err != nil {
        log.Fatal(err)
    }

    // ミドルウェアにコレクションを設定
    r.Use(setCollection("todos", co))

    // CORS 設定：適切に修正してください。
    var conf cors.Config = cors.DefaultConfig()
    conf.AllowAllOrigins = true
    conf.AllowCredentials = true
    conf.AllowMethods = []string{"GET", "POST", "PUT", "DELETE"}
    conf.AllowHeaders = []string{"Origin", "Authorization", "Content-Type"}
    r.Use(cors.New(conf))

    // ToDo アプリケーションの API エンドポイント定義
    r.GET("/todos", getAllTodos)
    r.GET("/todos/complete", getCompletedTodos)
    r.GET("/todos/:id", getTodo)
    r.POST("/todos", createTodo)
    r.PUT("/todos/:id", updateTodo)
    r.DELETE("/todos/:id", deleteTodo)

    // Swagger の設定
    docs.SwaggerInfo.Title = "Todo API"
    docs.SwaggerInfo.Version = "0.1.0"
    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))

    // API_PORT 環境変数からポート番号を取得
    var port string = os.Getenv("API_PORT")
    if port == "" {
        port = "5000"
    }

    // アプリケーションを指定されたポートで起動
    err = r.Run(":" + port)
    if err != nil {
        log.Fatal(err)
    }
}

// @Summary Get All Todos
// @Description すべての ToDo アイテムを取得します。
// @Tags todos
// @Accept json
// @Produce json
// @Success 200 {array} model.Todo
// @Router /todos [get]
func getAllTodos(ctx *gin.Context) {
    var todos []model.Todo
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    cursor, err := co.Find(nil, bson.M{}) // *mongo.Cursor, error
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    defer cursor.Close(nil)
    for cursor.Next(nil) {
        var todo model.Todo
        err = cursor.Decode(&todo)
        if handleError(ctx, 500, "Internal Server Error", err) {
            return
        }
        todos = append(todos, todo)
    }
    ctx.JSON(200, todos)
}

// @Summary Get Completed Todos
// @Description 完了した ToDo アイテムを取得します。
// @Tags todos
// @Accept json
// @Produce json
// @Success 200 {array} model.Todo
// @Router /todos/complete [get]
func getCompletedTodos(ctx *gin.Context) {
    var filter primitive.M = bson.M{"completed_date": bson.M{"$ne": nil}}
    var todos []model.Todo
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    cursor, err := co.Find(nil, filter) // *mongo.Cursor, error
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    defer cursor.Close(nil)
    for cursor.Next(nil) {
        var todo model.Todo
        err = cursor.Decode(&todo)
        if handleError(ctx, 500, "Internal Server Error", err) {
            return
        }
        todos = append(todos, todo)
    }
    ctx.JSON(200, todos)
}

// @Summary Get Todo
// @Description ID で ToDo アイテムを取得します。
// @Tags todos
// @Accept json
// @Produce json
// @Param id path string true "Todo ID"
// @Success 200 {object} model.Todo
// @Router /todos/{id} [get]
func getTodo(ctx *gin.Context) {
    var id string = ctx.Param("id")
    var todo model.Todo
    objId, err := primitive.ObjectIDFromHex(id) // primitive.ObjectID, error
    if handleError(ctx, 400, "Invalid ID", err) {
        return
    }
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    err = co.FindOne(nil, bson.M{"_id": objId}).Decode(&todo)
    if handleError(ctx, 404, "Todo not found", err) {
        return
    }
    ctx.JSON(200, todo)
}

// @Summary Create Todo
// @Description 新しい ToDo アイテムを追加します。
// @Tags todos
// @Accept json
// @Produce json
// @Param todo body model.Todo true "Todo to create"
// @Success 201 {object} model.Todo
// @Router /todos [post]
func createTodo(ctx *gin.Context) {
    var create model.Todo
    err := ctx.BindJSON(&create)
    if handleError(ctx, 400, "Invalid input", err) {
        return
    }
    create.Id = primitive.NewObjectID()
    create.CreatedDate = time.Now()
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    _, err = co.InsertOne(nil, create.ToMongo())
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    ctx.JSON(201, create.FromMongo())
}

// @Summary Update Todo
// @Description ToDo アイテムを更新します。
// @Tags todos
// @Accept json
// @Produce json
// @Param id path string true "Todo ID"
// @Param todo body model.Todo true "Todo to update"
// @Success 200 {object} model.Todo
// @Router /todos/{id} [put]
func updateTodo(ctx *gin.Context) {
    var id string = ctx.Param("id")
    objId, err := primitive.ObjectIDFromHex(id) // primitive.ObjectID, error
    if handleError(ctx, 400, "Invalid ID", err) {
        return
    }
    var update model.Todo
    err = ctx.BindJSON(&update)
    if handleError(ctx, 400, "Invalid input", err) {
        return
    }
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    var exist model.Todo
    err = co.FindOne(nil, bson.M{"_id": objId}).Decode(&exist)
    if handleError(ctx, 404, "Todo not found", err) {
        return
    }
    update.Id = exist.Id
    update.CreatedDate = exist.CreatedDate
    _, err = co.ReplaceOne(nil, bson.M{"_id": objId}, update)
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    ctx.JSON(200, update)
}

// @Summary Delete Todo
// @Description ID で ToDo アイテムを削除します。
// @Tags todos
// @Accept json
// @Produce json
// @Param id path string true "Todo ID"
// @Success 204 {object} nil
// @Router /todos/{id} [delete]
func deleteTodo(ctx *gin.Context) {
    var id string = ctx.Param("id")
    objId, err := primitive.ObjectIDFromHex(id) // primitive.ObjectID, error
    if handleError(ctx, 400, "Invalid ID", err) {
        return
    }
    co, ok := getCollection("todos", ctx) // *mongo.Collection, bool
    if !ok {
        return
    }
    _, err = co.DeleteOne(nil, bson.M{"_id": objId})
    if handleError(ctx, 500, "Internal Server Error", err) {
        return
    }
    ctx.JSON(204, nil)
}

// gin のコンテキストにコレクションを保持する関数
func setCollection(name string, co *mongo.Collection) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Set(name, co)
        c.Next()
    }
}

// gin のコンテキストにコレクションを取得する関数
func getCollection(name string, ctx *gin.Context) (*mongo.Collection, bool) {
    value, exists := ctx.Get(name) // any, bool
    if !exists {
        handleError(ctx, 500, "Internal Server Error", errors.New("Collection not found in context."))
        return nil, false
    }
    co, ok := value.(*mongo.Collection) // *mongo.Collection, bool
    if !ok {
        handleError(ctx, 500, "Internal Server Error", errors.New("Failed to cast collection."))
        return nil, false
    }
    return co, true
}

// カスタムのエラーハンドリング関数
func handleError(ctx *gin.Context, code int, msg string, err error) bool {
    if err != nil {
        log.Println(msg + ": " + err.Error())
        ctx.JSON(code, gin.H{"error": "An internal server error occurred."})
        return true
    }
    return false
}

Swag でドキュメントを生成します。

$ swag init
2024/08/11 11:27:51 Generate swagger docs....
2024/08/11 11:27:51 Generate general API Info, search dir:./
2024/08/11 11:27:51 create docs.go at docs/docs.go
2024/08/11 11:27:51 create swagger.json at docs/swagger.json
2024/08/11 11:27:51 create swagger.yaml at docs/swagger.yaml

Swagger を確認

Web ブラウザで Swagger の URL を確認します。

http://localhost:5000/swagger/index.html

これらのツールを活用することにより、より手軽に API を操作できます。

まとめ

WSL Ubuntu の Docker 環境で、Go Gin の最小 API を実装することができました。

この記事の実装例は1つのアプローチに過ぎず、必ずしも正しい方法とは限りません。他にも多様な方法がありますので、さまざまな情報を照らし合わせて検討してみてください。

どうでしたか？　WSL Ubuntu で、Go Gin Web アプリケーションを手軽に起動できます。ぜひお試しください。今後も Go の開発環境などを紹介しますので、ぜひお楽しみにしてください。

You get articles that match your needs
You can efficiently read back useful information
You can use dark theme

What you can do with signing up

Docker 環境と Go Gin で最小 API を実装する：MongoDB

Docker 環境と Go Gin で最小 API を実装する：MongoDB

目的

実現すること

技術トピック

Gin とは？

Gin (ジン)

開発環境

作成する REST API の仕様

データベース コンテナーの起動

REST API を実装する手順

Go 言語のインストール

プロジェクトの作成

モデルファイルの作成

アプリケーションファイルの作成

パッケージの追加

アプリのビルドと起動

アプリの動作確認

GET: /todos エンドポイントの動作確認

GET: /todos/complete エンドポイントの動作確認

GET: /todos/{id} エンドポイントの動作確認

POST: /todos エンドポイントの動作確認

PUT: /todos/{id} エンドポイントの動作確認

DELETE: /todos/{id} エンドポイントの動作確認

コンテナーイメージの作成

コンテナーを起動

コンテナーの動作確認

コンテナーに接続

おまけ：Swagger 装備

ライブラリの追加

コードの修正

Swagger を確認

まとめ

データベースコンテナーの起動