[Go] groupcache

#Go

그룹캐시는 memcached 같은 인메모리 대체용으로 만들어진 분산 캐싱용 라이브러리다. memcached 개발자가 직접 만들었다.
현재 구글 내부에서 다운로드 서버 등에 많이 사용된다고 한다.

memcached 같은 인메모리 DB들과의 가장 큰 차이점은, DB를 별도로 띄우는게 아니라 in-program으로 Go 코드 내에서만 동작한다는 것이다.

쉽게 말해서, 인메모리 DB를 GO 프로그램 내에서 직접 만드는 것이다.
막 원클릭 투클릭으로 생성할 정도로 편하게 만들어져있는건 아니고, 사용사례에 따라서 직접 구현해서 핸들링해야 하는 부분이 많다. Memcache 대체용이라고는 하지만 1:1 대응이 되는 구조도 아니다. 많이 다르다.

그래서 많이 안쓰는 것 같다.

간단한 예제

한번 싱글노드에서 그룹캐시를 만드는 방법을 정리해보겠다.
진짜 기본적인 로직만 있다.

전역변수로 인메모리 데이터를 두고

그룹을 생성함과 동시에, Get에서 방금 저 전역 데이터를 가져오도록 했다.

그러면 Group 객체를 통해 값을 가져오도록 할 수 있다.

package main

import (
	"context"
	"errors"
	"log"

	"github.com/golang/groupcache"
)

var Store = map[string][]byte{
	"red":   []byte("#FF0000"),
	"green": []byte("#00FF00"),
	"blue":  []byte("#0000FF"),
}

var Group = groupcache.NewGroup("foobar", 64<<20, groupcache.GetterFunc(
	func(ctx context.Context, key string, dest groupcache.Sink) error {
		log.Println("looking up", key)
		v, ok := Store[key]
		if !ok {
			return errors.New("color not found")
		}
		dest.SetBytes(v)
		return nil
	},
))

func main() {
	var b []byte

	err := Group.Get(nil, "red", groupcache.AllocatingByteSliceSink(&b))
	if err != nil {
		log.Fatal(err)
		return
	}

	log.Println("red", string(b))
}

잘 동작은 하지만 서버도 없고, Set도 없고, 분산 구성도 안되어있어서 불완전한 구성이다.

이제 확장해보자.

HTTP 서버 구성 (Read Only)

일단 데이터 몇개만 있고, 단순 조회만 가능한 단일 싱글 캐시서버를 만들어보겠다.
실제로 이런 형태로 쓸 일은 없을 것이다.

서버를 적절히 이런 형태로 만들어준다.
GET으로 들어오면 그룹캐시에서 캐시값을 반환하는 간단한 로직만을 포함한다.

그렇게 실행하면

잘 동작할 것이다.

아래는 전체 코드다.

package main

import (
	"errors"
	"fmt"
	"log"
	"net/http"

	"github.com/golang/groupcache"
)

var Store = map[string][]byte{
	"red":   []byte("#FF0000"),
	"green": []byte("#00FF00"),
	"blue":  []byte("#0000FF"),
}

var Group = groupcache.NewGroup("foobar", 64<<20, groupcache.GetterFunc(
	func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
		log.Println("looking up", key)
		v, ok := Store[key]
		if !ok {
			return errors.New("color not found")
		}
		dest.SetBytes(v)
		return nil
	},
))

func main() {
	myPort := ":8888"

	me := fmt.Sprintf("http://localhost%s", myPort)
	peers := []string{"http://localhost:8888"}

	http.HandleFunc("/color", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			color := r.URL.Query().Get("key")
			var b []byte
			err := Group.Get(nil, color, groupcache.AllocatingByteSliceSink(&b))
			if err != nil {
				http.Error(w, err.Error(), http.StatusNotFound)
				return
			}
			w.Write(b)
			w.Write([]byte{'\n'})
		case http.MethodPost:
		}
	})
	pool := groupcache.NewHTTPPool(me)
	pool.Set(peers...)

	fmt.Println("Groupcache server is running on", myPort)
	http.ListenAndServe(myPort, nil)
}

여기서는 메모리에 값을 저장하고 그걸 캐시되도록 했지만, File Read나 Network I/O로 가져오게 구성해도 GroupCache 자체적으로 인메모리 캐시에 넣는다.

HTTP 서버 구성 (쓰기 가능)

이번에는 쓰기가 가능하게도 만들어보자.

근데 여기서는 그냥 쓰기 작업을 할 수 없는 것이, 당연히 http 요청에 의한 프로세스는 병렬적으로 실행될 수 있다.
그냥 무작정 쓰면 동시성 write로 패닉 대잔치가 발생할 것이다.

안전한 쓰기를 위해서 Lock을 하나 둬야 한다.
캐시 특성상 쓰기보다는 읽기가 많기 때문에 RWMutex로 뒀다.

읽을 때도 락을 걸어주고

쓰기 동작을 구현해서, 거기에도 락을 걸어준다.

아래는 전체 코드다.

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"sync"

	"github.com/golang/groupcache"
)

var Store = map[string][]byte{
	"red":   []byte("#FF0000"),
	"green": []byte("#00FF00"),
	"blue":  []byte("#0000FF"),
}

var StoreLock sync.RWMutex

var Group = groupcache.NewGroup("foobar", 64<<20, groupcache.GetterFunc(
	func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
		log.Println("looking up", key)
		StoreLock.RLock()
		v, ok := Store[key]
		StoreLock.RUnlock()
		if !ok {
			return errors.New("color not found")
		}
		dest.SetBytes(v)
		return nil
	},
))

func main() {
	myPort := ":8888"

	me := fmt.Sprintf("http://localhost%s", myPort)
	peers := []string{me}

	ctx := context.Background()

	http.HandleFunc("/color", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			color := r.URL.Query().Get("key")
			var b []byte

			err := Group.Get(ctx, color, groupcache.AllocatingByteSliceSink(&b))
			if err != nil {
				http.Error(w, err.Error(), http.StatusNotFound)
				return
			}
			w.Write(b)
			w.Write([]byte{'\n'})
		case http.MethodPost:
			bytedata, err := io.ReadAll(r.Body)

			if err != nil {
				w.Write([]byte("Invalid data"))
				return
			}

			type KV struct {
				Key   string `json:"key"`
				Value string `json:"value"`
			}

			var kv KV
			err = json.Unmarshal(bytedata, &kv)
			if err != nil {
				w.Write([]byte("Invalid JSON"))
				return
			}

			StoreLock.Lock()
			Store[kv.Key] = []byte(kv.Value)
			StoreLock.Unlock()

			w.Write([]byte("OK"))
		}
	})
	pool := groupcache.NewHTTPPool(me)
	pool.Set(peers...)

	fmt.Println("Groupcache server is running on", myPort)
	http.ListenAndServe(myPort, nil)
}