Docker環境下でGoとRedisでAPIを実装する (Part.2)

はじめに

本記事は、GoとRedisでAPIを実装する (Part.1)の続きである。まだ、読んでいない方は事前に読んでいただけると幸いである。

Part.2では、APIの実装から検証を行う。

まず今回の実装に至り、実行環境は以下の通りである。

1. 実行環境

• macOS Catalina Ver.10.15.2
• Docker version 19.03.5, build 633a0ea
• docker-compose version 1.24.1, build 4667896b
• golang 1.13.6
• Redis 5.0.7

1.1. ファイル構成

file-tree

sample_project
├── docker
│   ├── api
│   │   └── Dockerfile-api //API用
│   └── database
│       └── Dockerfile-redis //DB用
├── docker-compose.yml
└── src
    └── app
        ├── controller
        │   ├── sender.go
        │   └── receiver.go
        ├── infrastructure
        │   └── database.go
        ├── interface
        │   └── user.go
        └── main.go

2. APIの実装

今回の実装では、JSON形式のデータを扱う事にする。

sampleData.json

{
	// ユーザID
	"ID"	: "A000000",
	// ユーザ名
	"Name"	: "Bob",
	// 年齢
	"Age"	: 18,
}

Sender / Reciever それぞれの処理内容としては、以下の通りである。

• Sender側
  • JSON形式のデータをRedisに格納する。
    • Redisで使用するキーパターンは以下の通りである
    • 「ユーザID:ユーザ名」例)A000000:Bob
• Receiver側
  • キーを使用し、edis内からデータを取得する。

また、今回は重複データが存在する場合、データが更新されるようにする。

2.1. main.go

まず、main.goについて説明する。ここで行う事はHTTP通信のみである。gin.Default()でデフォルトのミドルウェアと共にルータを作成し、それぞれのエンドポイントで行う処理を指定する。

main.go

package main

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

func main() {
	router := gin.Default()

	// Sender
	router.POST("/sender", controller.Send())

	// Receiver
	router.GET("/receiver", controller.Receiver())

	// PORT環境変数が未指定の場合、デフォルトで8080で待受する
	router.Run()
}

今回は分かりやすい様、エンドポイントを/sender、/receiverにする。

2.2. interface/user.go

JSONで渡されるデータを受け取る為に、構造体を用意しておく。

interface/user.go

package _interface

type UserInformation struct {
	// ユーザID
	ID		string	`json:"id"`
	// ユーザ名
	Name	string	`json:"name"`
	// 年齢
	Age		int 	`json:"age"`
}

2.3. Redisへの接続 / 切断

Redisへの接続処理を逐一記述するのは少し面倒であるし、複数箇所でこの処理を記述するのも可読性が悪い。その為、接続処理をインスタンス化する事で、処理を集約化した。

database.go

import (
	"github.com/garyburd/redigo/redis"
	"os"
)

type Redis struct {
	connection redis.Conn
}

// Redisへの接続
func NewRedis() *Redis {
	// IPポートの設定
	const ipPort = "redis:6379"
	// redisに接続する
	c, err := redis.Dial("tcp", ipPort)
	if err != nil {
		panic(err)
	}
	// 接続情報をConnインタフェースのconnectionに保存
	r := &Redis{
		connection: c,
	}
	return r
}
// Redisからの切断
func (r *Redis) CloseRedis() {
	// redisとの通信を切断する
	_ = r.connection.Close()
}

ポート番号はデフォルトの6379に設定している。
Connインタフェースは、Redisを使用する為の主要なインターフェースである。
また、切断処理もメソッド化しておく。

2.4. Sender

2.4.1. controller/sender.go

Sender側の処理について説明する。

controller/sender.go

package controller

import (
	"app/infrastructure"
	"app/interface"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
)

func Send() gin.HandlerFunc {
	return func(context *gin.Context) {
		// Redisに接続する
		redis := infrastructure.NewRedis()
		// Send()処理終了後にRedisとの接続を切断する
		defer redis.CloseRedis()

		// requestInformationをUserInformationで初期化する
		requestInformation := _interface.UserInformation{}

		// 構造体をBINDする
		err := context.Bind(&requestInformation)
		if err != nil{
			context.JSON(http.StatusBadRequest, gin.H{"Status": "BadRequest"})
		}

		// Redisで使用するキーの作成
		key := requestInformation.ID + ":" + requestInformation.Name

		// 作成した構造体requestInformationをJSONに変換する
		payload, err := json.Marshal(requestInformation)
		if err != nil {
			fmt.Println("JSON Marshal Error : ", err)
			return
		}

		// key, payloadを引数にRedisに追加する
		if err := redis.Set(key, payload); err != nil {
			fmt.Println("Failed to store data in Redis. ", err)
		} else {
			context.JSON(http.StatusOK, gin.H{"Status": "Successfully added to redis. "})
		}
	}
}

一度、取得したデータを構造体requestInformationに格納し、その後にjson.Marshal()でJSON文字列に変換する。今回、Redisで使用するキーの生成はこのファイル内で簡素的に生成している。生成したkeyとpayloadを引数にdatabase.goの関数Set(key, payload)に渡す。

2.4.2. infrastructure/database.go (SET)

先程の、database.goにRedisへデータを追加する処理を追記する。

database.go

import (
	"fmt"
	"github.com/garyburd/redigo/redis"
	"os"
)

// ...省略

// Redisへのデータ追加
func (r *Redis) Set(key string, payload []byte) error {
	// 生成したキーが既に存在するかチェックする
	if r.keyExist(key) == true {
		fmt.Println("Delete the key because it was already registered in redis.")
		fmt.Println("Update an existing key.")
		// 存在する場合、データを更新する
		r.update(key, payload)
	} else {
		// キーをRedisに追加する
		if _, err := r.connection.Do("SET", key, payload); err != nil {
			fmt.Println("infrastructure/database/Set() : ", err)
			os.Exit(1)
			return err
		}
	}
	return nil
}

// キーチェック
func (r *Redis) keyExist(key string) bool {
	// キーが既にRedis内に存在するかチェックする
	result, err := redis.Bool(r.connection.Do("EXISTS", key))
	if err != nil {
		fmt.Println("infrastructure/database/keyExist() : ", err)
	}
	return result
}

// データの更新
func (r *Redis) update(key string, payload []byte) {
	// キーから値を取得後、新たなデータを登録する
	_, err := r.connection.Do("GETSET", key, payload)
	if err != nil {
		fmt.Println("infrastructure/database/update() : ", err)
	}
}

今回は、重複したデータを削除する処理を入れているので、一度keyExist()でRedis内にキーが存在するかチェックする。存在する場合は、update()で既存のキーからデータを取得し、新たなデータを更新する。redisにはUPDATEはないので、代わりにGETSETを使用し、更新を行う。

これでSender側の処理は終了である。

2.5 Receiver

2.5.1. controller/receiver.go

次にReceiver側の処理について説明する。ここでは、パラメータから取得したkeyを使用し、redisからデータを取得する。

controller/receiver.go

package controller

import (
	"app/infrastructure"
	_interface "app/interface"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
)

func Receive() gin.HandlerFunc {
	return func(context *gin.Context) {
		// Redisに接続
		redis := infrastructure.NewRedis()
		// Receive()処理終了後にRedisとの接続を切断する
		defer redis.CloseRedis()

		// クエリストリングパラメーターを取得
		key := context.Query("key")

		// responseInformationをUserInformationで初期化する
		responseInformation := _interface.UserInformation{}

		// Redisからデータを取得する
		if payload, err := redis.Get(key); err != nil {
			fmt.Println("Failed to get data from Redis. :", err)
		} else {
			// Redisから取得したpayloadをGo Object(構造体)に変換する
			if err := json.Unmarshal(payload, &responseInformation); err != nil {
				fmt.Println("Could not Unmarshal the retrieved json. :", err)
			}
			context.JSON(http.StatusOK, responseInformation)
		}
	}
}

Receiverでは、Redisに格納されているデータをクエリストリングパラメータ(URLパラメータとも言う)から、データを取得する。取得後は、json.Unmarshal()を行い、Go Objectとして構造体UserInformationに変換する。

2.5.2. infrastructure/database.go (GET)

また先程の、database.goにGET処理を追記する。

database.go

import (
	"fmt"
	"github.com/garyburd/redigo/redis"
	"os"
)

// ...省略

func (r *Redis) Get(key string) ([]byte, error) {
	// キーを使用し、Redisからデータを追加する
	payload, err := redis.Bytes(r.connection.Do("GET", key))
	if err != nil {
		fmt.Println("infrastructure/database/Set() : ", err)
		return payload, err
	}
	return payload, err
}

以上で、Sender / Receiverの処理は終了である。

では、最後に検証を行う。

3. 検証

検証では、Talend API Testerや、Postmanと言ったツールを使用すると良い。今回は、Postmanを使用して検証を行う。

3.1. Sender

以下のURLにJSONをPOST通信で渡している。正常に渡せていれば結果として"Status": "Successfully added to redis. "が返ってくる。

• URL

  • http://localhost:8080/sample_project/sender

• 結果

Status-Success

{
    "Status": "Successfully added to redis. "
}

また、Redisに正しくデータが登録されているかどうかを確認する。確認はsample_project/redis:0.1.0のコンテナに入り、以下のコマンドを確認すると良い。

redis-cli

$ docker exec -it [CONTAINER ID] sh
/data # redis-cli
127.0.0.1:6379> GET key(自分で設定したキー)
"{\"id\":\"sample001\",\"name\":\"test001\",\"age\":99}"

IDEなどでDBが確認できるプラグインもあるが、その際はlocalhost:6379を指定して確認すると良い。

3.2. Receiver

GET通信なので、URL内にパラメータとしてkeyを渡す。データが取得できれば、結果として登録したデータが返ってくる。

検証としては、以上である。

4. まとめ

今回は、2つの記事に渡り、APIの実装について記述した。今回の内容を参考にしていただければ幸いである。

また、この実装は簡素的なものであるため、懸念点なども多い。今後は、その点の改善を行っていこうと思う。

追記

• サンプルコード
  • ホットリロードをFreshから、Airに変更