Golang Application을 docker compose로 개발하기

Recommanded Free YOUTUBE Lecture: High Avalibility Application On AWS Cloud

yundream
2023-10-02
2023-10-02
1843

docker-compose and golang

소개

앞서 Golang Application docker 빌드 에서 Golang 애플리케이션을 Docker 에서 빌드하고 Docker 이미지 형태로 배포하는 것을 살펴봤다. 하지만 대부분의 애플리케이션은 데이터베이스 혹은 다른 애플리케이션과 통신을 해야 한다. 이 경우 단일 docker 이미지 형태로 배포하면 테스트하기가 쉽지 않다.

docker compose를 이용하면, Docker 네트워크를 통해서 여러 개의 컨테이너로 구성된 서비스를 구축할 수 있다.

여기에서는 docker compose를 이용해서 MySQL 데이터베이스를 사용하는 Go 애플리케이션을 만들어 볼 것이다.

조건

이 문서를 따라하기 위해서는 아래의 조건이 갖춰져 있어야 한다.

Ubuntu 리눅스: Ubuntu 리눅스가 설치된 로컬 PC 혹은 가상 머신
Docker 설치
Docker-compose 설치: Ubuntu Linux에 docker compose 설치하기 참고.
Golang Application docker 빌드: GoLang 애플리케이션을 dockerizing 하는 법.
git 설치: 예제는 github에서 다운로드(clone)할 수 있다.

애플리케이션 아키텍처

우리는 counter 애플리케이션을 만들려고 한다. 이 애플리케이션은 Go로 만들어진 count API 서버와 count 정보를 저장하는 MySQL 데이터베이스로 구성된다. 이 애플리케이션은 최종적으로 Kubernetes에 배포될 건데, 배포 전에 로컬에서 테스트 환경을 갖추길 원하고 있다. 개발팀은 docker-compose를 이용해서 로컬 빌드/개발 환경을 구축하기로 했다. 아키텍처는 아래와 같다.

애플리케이션 아키텍처

GoLang 애플리케이션은 2개의 API를 제공한다.

GET /api/count: 현재 count 값을 읽어서 리턴한다.
PUT /api/count: count의 값을 1만큼 증가 시킨다.

GoLang 애플리케이션

$ git clone https://github.com/yundream/joinc-go-hello

전체 예제 코드는 https://github.com/yundream/joinc-go-hello 에서 다운로드 할 수 있다.

package main

import (
	"fmt"
	"net/http"
	"os"
	"time"

	"github.com/gorilla/mux"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var (
	db *gorm.DB
)

type Counter struct {
	gorm.Model
	Name  string `gorm:"size:16"`
	Count int
}

func main() {
	_, err := GetDatabaseInstance()
	if err != nil {
		fmt.Println(">> ", err.Error())
		time.Sleep(2 * time.Second)
		os.Exit(1)
	}

	r := mux.NewRouter()
	fmt.Println("Server start!!")
	r.HandleFunc("/api/count", getCounter).Methods("GET")
	r.HandleFunc("/api/count", addCounter).Methods("POST")
	http.ListenAndServe(":8000", r)
}

func addCounter(w http.ResponseWriter, r *http.Request) {
	tx := db.Exec("UPDATE counters SET count=count+1 WHERE name='count'")
	if tx.Error != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w, "Error:%s", tx.Error.Error())
		return
	}
}

func getCounter(w http.ResponseWriter, r *http.Request) {
	readCounter := &Counter{}
	tx := db.Where("name=?", "count").First(&readCounter)
	if tx.Error != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w, "Error:%s", tx.Error.Error())
		return
	}
	fmt.Fprintf(w, "%d", readCounter.Count)
}

func GetDatabaseInstance() (*gorm.DB, error) {
	var (
		retry    int
		database *gorm.DB
		err      error
	)
	retry = 0
	dbUser := os.Getenv("MYSQL_USER")
	dbPass := os.Getenv("MYSQL_PASSWORD")
	dbName := os.Getenv("MYSQL_DATABASE")
	dbHost := os.Getenv("MYSQL_HOST")
	dbPort := os.Getenv("MYSQL_PORT")

	createDBDsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
	)

	for retry < 3 {
		time.Sleep(10 * time.Second)
		database, err = gorm.Open(mysql.Open(createDBDsn), &gorm.Config{})
		if err == nil {
			break
		}
		retry++
	}
	if err != nil {
		fmt.Println(">> ", err.Error(), createDBDsn)
		return nil, err
	}

	tx := database.Exec("CREATE DATABASE IF NOT EXISTS " + dbName + ";")
	if tx.Error != nil {
		return nil, tx.Error
	}
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
		dbName,
	)
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	isTable := db.Migrator().HasTable(&Counter{})
	fmt.Println("isTable", isTable)
	err = db.AutoMigrate(&Counter{})
	if err == nil {
		if !isTable {
			db.Create(&Counter{Name: "count", Count: 0})
		}
	}
	return db, nil
}

예제 코드 치고는 코드 길이가 제법된다. 중요 부분을 하나씩 떼어내서 살펴보자.

import(
	"github.com/gorilla/mux"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

API 개발을 위해서 gorilla 웹 툴킷을 이용했다. gin, Revel 같은 웹 프레임워크에 비교해서 기능은 부족하지만 간단하게 사용 할 수 있어서 널리 사용하고 있다.

데이터베이스를 관리하기 위해서 ORM 라이브러리인 gorm을 사용했다. docker-compose로 애플리케이션을 개발 할경우, 데이터베이스 스키마를 만들어줘야 하는데 gorm의 automigration을 이용해서 자동으로 테이블을 생성할 수 있다.

type Counter struct {
	gorm.Model
	Name  string `gorm:"size:16"`
	Count int
}

gorm이 사용할 Counter 구조체다. 나중에 gorm은 이 구조체를 기반으로 테이블 스키마를 만들고, 쿼리를 실행한다.

func main() {
	_, err := GetDatabaseInstance()
	if err != nil {
		fmt.Println(">> ", err.Error())
		time.Sleep(2 * time.Second)
		os.Exit(1)
	}

	r := mux.NewRouter()
	fmt.Println("Server start!!")
	r.HandleFunc("/api/count", getCounter).Methods("GET")
	r.HandleFunc("/api/count", addCounter).Methods("POST")
	http.ListenAndServe(":8000", r)
}

GET /api/count과 POST /api/count 2개의 API를 만들었다.

func addCounter(w http.ResponseWriter, r *http.Request) {
	tx := db.Exec("UPDATE counters SET count=count+1 WHERE name='count'")
	if tx.Error != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w, "Error:%s", tx.Error.Error())
		return
	}
}

func getCounter(w http.ResponseWriter, r *http.Request) {
	readCounter := &Counter{}
	tx := db.Where("name=?", "count").First(&readCounter)
	if tx.Error != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w, "Error:%s", tx.Error.Error())
		return
	}
	fmt.Fprintf(w, "%d", readCounter.Count)
}

GET /api/count 과 POST /api/count를 위한 handler 함수다. getCounter는 count 값을 읽어서 리턴하고, addCounter는 count를 1 증가시킨다.

func GetDatabaseInstance() (*gorm.DB, error) {
	var (
		retry    int
		database *gorm.DB
		err      error
	)
	retry = 0
	dbUser := os.Getenv("MYSQL_USER")
	dbPass := os.Getenv("MYSQL_PASSWORD")
	dbName := os.Getenv("MYSQL_DATABASE")
	dbHost := os.Getenv("MYSQL_HOST")
	dbPort := os.Getenv("MYSQL_PORT")

	createDBDsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
	)

데이터베이스와 관련된 정보를 환경변수를 통해서 관리하기로 했다. 환경변수를 이용해서 관리 하면, 별도의 환경파일을 관리 할 필요가 없고, Docker 컨테이너를 실행할 때, 컨테이너 변수로 데이터베이스 설정 값을 넘길 수 있다는 장점이 있다. 나중에 ECS, Kubernetes 등으로 배포할 때도 환경변수를 이용하여 좀 더 쉽게 배포 할 수 있다.

	for retry < 3 {
		time.Sleep(10 * time.Second)
		database, err = gorm.Open(mysql.Open(createDBDsn), &gorm.Config{})
		if err == nil {
			break
		}
		retry++
	}
	if err != nil {
		fmt.Println(">> ", err.Error(), createDBDsn)
		return nil, err
	}

	tx := database.Exec("CREATE DATABASE IF NOT EXISTS " + dbName + ";")
	if tx.Error != nil {
		return nil, tx.Error
	}

docker-compose로 실행 할 경우, mysql 컨테이너와 counter app 컨테이너를 따로 실행하게 된다. 이때 mysql 컨테이너가 실행 된 후 counter app 컨테이너를 실행하도록 설정을 할 것이다. 그런데 mysql의 경우 컨테이너가 실행된 뒤에도 실제 연결이 가능할 때까지 시간이(약 10초) 걸리게 된다. 이때 연결을 시도하면 에러가 발생하므로 10초 간격으로 3번 연결 시도를 하도록 코드를 변경했다.

참고로 이 예제코드는 코드안에서 데이터베이스 연결을 retry 체크하는데, 이렇게 하지 않고 docker-compose 설정을 변경해서 컨테이너가 종료되면 컨테이너를 다시 시작하도록 할 수 있다. 아마 이 방법이 더 편할 건데, docker-compose 설정파일 부분에서 자세히 살펴보도록 하겠다.

DB 연결이 끝났다면 "CREATE DATABASE IF NOT EXISTS dbName" 쿼리를 이용해서 dbName 데이터베이스가 없을 경우 새로 데이터베이스를 생성하도록 했다.

	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
		dbName,
	)
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	isTable := db.Migrator().HasTable(&Counter{})
	fmt.Println("isTable", isTable)
	err = db.AutoMigrate(&Counter{})
	if err == nil {
		if !isTable {
			db.Create(&Counter{Name: "count", Count: 0})
		}
	}
	return db, nil

이제 환경 변수 값을 이용해서 dsn 을 만들고 mysql 데이터베이스에 연결한다.

연결하고 나면 db.Migrator() 를 호출해서 Counter 구조체를 기반으로 테이블을 마이그레이션 한다. 만약 테이블이 없건나, 테이블 스키마가 변경됐다면 자동으로 테이블을 생성 혹은 변경해준다.

테이블을 새로 만드는 경우 db.Create를 호출해서 count 를 0으로 설정한다.

예제 코드를 docker 이미지로 만들기

Make가 설치돼 있으면 "make"를 실행하면 된다. 혹은 build 명령을 이용해서 직접 이미지를 만들어도 된다.

$ docker build -t joinc/counter:0.1 -t joinc/counter:latest .

docker-compose.yml 설정파일

이제 docker-compose.yml 파일을 분석해 보자.

version: "3.0"

networks:
  joinc-nw:

services:
  counter-app:
    image: joinc/counter:latest
    ports:
      - "8000:8000"
    depends_on:
      - counter-db 
    networks:
      - joinc-nw
    environment:
      MYSQL_USER: "root"
      MYSQL_PASSWORD: "1234"
      MYSQL_DATABASE: "counter"
      MYSQL_PORT: "3306"
      MYSQL_HOST: "counter-db"

  counter-db:
    image: mysql:latest
    ports:
      - "3306"
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    networks:
      - joinc-nw

joinc-nw 를 만들었다. driver를 따로 설정하지 않았는데, 이 경우 bridge driver가 설정된다. 위 설정은 아래와 같이 바꿀 수 있다.

networks:
  joinc-nw:
    driver: bridge

counter-app 서비스 설정을 보자.

  counter-app:
    image: joinc/counter:latest
    ports:
      - "8000:8000"
    depends_on:
      - counter-db 
    networks:
      - joinc-nw
    environment:
      MYSQL_USER: "root"
      MYSQL_PASSWORD: "1234"
      MYSQL_DATABASE: "counter"
      MYSQL_PORT: "3306"
      MYSQL_HOST: "counter-db"

image: joinc/counter:latest 이미지로 컨테이너를 만든다.
ports: 8000 번 포트로 포트포워딩 했다.
depends_on: counter-mysql 컨테이너가 실행되고 나면, 실행한다.
networks: joinc-nw 네트워크를 사용한다.
environment: 컨테이너가 시작될 때 설정될 환경 변수들이다. Go 애플리케이션은 이 환경변수를 읽어서 데이터베이스에 연결할 수 있다. MYSQL_HOST는 데이터베이스 서버의 이름인데, services 블록의 서비스 이름 "counter-db"으로 서버를 찾을 수 있다.

MySQL 데이터베이스의 service 블록 정보를 보자.

  counter-db:
    image: mysql:latest
    ports:
      - "3306"
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    networks:
      - joinc-nw

image: mysql 최신 이미지로 컨테이너를 실행한다.
ports: mysql의 기본 포트 3306을 사용한다.
envorionment: MySQL 서버의 root 패스워드를 설정한다.
networks: joinc-nw를 사용한다.

docker-compose 실행

docker-compose up 명령으로 애플리케이션을 실행해보자.

$ docker-compose up   
[+] Running 2/0
 ✔ Container docker-compose-counter-db-1   Created        0.0s 
 ✔ Container docker-compose-counter-app-1  Recreated      0.0s 
Attaching to docker-compose-counter-app-1, docker-compose-counter-db-1

docker-compose ps 명령으로 컨테이너를 확인해 보자.

curl 을 이용해서 GET /api/count 와 POST /api/count가 잘 작동하는지 테스트해보자.

$ curl localhost:8000/api/count
0
$ curl -XPOST localhost:8000/api/count
$ curl localhost:8000/api/count
1

잘 작동하는 걸 확인할 수 있다.

정리

이 문서에서 실행한 docker-compose 애플리케이션 아키텍처는 아래와 같이 묘사할 수 있을 것이다.

services는 counter-app 과 docunter-db 컨테이너로 구성된다. 이들 컨테이너는 joinc-nw로 서로 연결된다. 각 컨테이너는 IP가 아닌 service name 으로 찾을 수 있기 때문에 IP를 설정할 필요가 없다.

Kubernetes 나 ECS와 같은 컨테이너 기반으로 애플리케이션을 실행 할 경우, 로컬 테스트 환경 구성이 까다로워질 수 있는데, docker-compose.yml을 함께 배포하면 로컬 개발환경도 깔끔하게 구성 할 수 있다.

조금 더 부지런하면 minikube로 구축할 수도 있는데, 개발 팀이 minikube를 이용해서 개발환경을 구축하는 것은 너무 복잡하다. docker-compose를 검토해 보자.

![docker-compose and golang](https://docs.google.com/drawings/d/e/2PACX-1vT6umBFoVj_wMrf86iaPd-jBabtyzUVDSfyOe1_5kVUl0yZGUs6P0PX-OO6UG1L7jrR_ot5feVzsEi_/pub?w=1856&h=900)
### 소개
앞서 [Golang Application docker 빌드](https://www.joinc.co.kr/w/golang_docker) 에서 Golang 애플리케이션을 Docker 에서 빌드하고 Docker 이미지 형태로 배포하는 것을 살펴봤다. 하지만 대부분의 애플리케이션은 데이터베이스 혹은 다른 애플리케이션과 통신을 해야 한다. 이 경우 단일 docker 이미지 형태로 배포하면 테스트하기가 쉽지 않다.

docker compose를 이용하면, Docker 네트워크를 통해서 여러 개의 컨테이너로 구성된 서비스를 구축할 수 있다.

여기에서는 docker compose를 이용해서 MySQL 데이터베이스를 사용하는 Go 애플리케이션을 만들어 볼 것이다.

## 조건
이 문서를 따라하기 위해서는 아래의 조건이 갖춰져 있어야 한다.
* Ubuntu 리눅스: Ubuntu 리눅스가 설치된 로컬 PC 혹은 가상 머신 
* Docker 설치
* Docker-compose 설치: [Ubuntu Linux에 docker compose 설치하기](https://www.joinc.co.kr/w/docker_compose_starter) 참고.
* [Golang Application docker 빌드](https://www.joinc.co.kr/w/golang_docker): GoLang 애플리케이션을 dockerizing 하는 법.
* git 설치: 예제는 github에서 다운로드(clone)할 수 있다.

## 애플리케이션 아키텍처 
우리는 **counter** 애플리케이션을 만들려고 한다. 이 애플리케이션은 Go로 만들어진 count API 서버와 count 정보를 저장하는 MySQL 데이터베이스로 구성된다. 이 애플리케이션은 최종적으로 Kubernetes에 배포될 건데, 배포 전에 로컬에서 테스트 환경을 갖추길 원하고 있다. 개발팀은 docker-compose를 이용해서 로컬 빌드/개발 환경을 구축하기로 했다. 아키텍처는 아래와 같다.

![애플리케이션 아키텍처](https://docs.google.com/drawings/d/e/2PACX-1vSC3rWDZBjYvx2Rr5iziM5v488CwgUUJFmdFJzyiIUz557AZOnCeWFLRPYQRzXEMnOZ5sJ3cbn22RzO/pub?w=616&h=147)

GoLang 애플리케이션은 2개의 API를 제공한다.
1. GET /api/count: 현재 count 값을 읽어서 리턴한다. 
2. PUT /api/count: count의 값을 1만큼 증가 시킨다.

## GoLang 애플리케이션
```shell
$ git clone https://github.com/yundream/joinc-go-hello
```
전체 예제 코드는 https://github.com/yundream/joinc-go-hello 에서 다운로드 할 수 있다. 
```go
package main

import (
	"fmt"
	"net/http"
	"os"
	"time"

"github.com/gorilla/mux"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var (
	db *gorm.DB
)

type Counter struct {
	gorm.Model
	Name  string `gorm:"size:16"`
	Count int
}

func main() {
	_, err := GetDatabaseInstance()
	if err != nil {
		fmt.Println(">> ", err.Error())
		time.Sleep(2 * time.Second)
		os.Exit(1)
	}

r := mux.NewRouter()
	fmt.Println("Server start!!")
	r.HandleFunc("/api/count", getCounter).Methods("GET")
	r.HandleFunc("/api/count", addCounter).Methods("POST")
	http.ListenAndServe(":8000", r)
}

func addCounter(w http.ResponseWriter, r *http.Request) {
	tx := db.Exec("UPDATE counters SET count=count+1 WHERE name='count'")
	if tx.Error != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w, "Error:%s", tx.Error.Error())
		return
	}
}

func getCounter(w http.ResponseWriter, r *http.Request) {
	readCounter := &Counter{}
	tx := db.Where("name=?", "count").First(&readCounter)
	if tx.Error != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w, "Error:%s", tx.Error.Error())
		return
	}
	fmt.Fprintf(w, "%d", readCounter.Count)
}

func GetDatabaseInstance() (*gorm.DB, error) {
	var (
		retry    int
		database *gorm.DB
		err      error
	)
	retry = 0
	dbUser := os.Getenv("MYSQL_USER")
	dbPass := os.Getenv("MYSQL_PASSWORD")
	dbName := os.Getenv("MYSQL_DATABASE")
	dbHost := os.Getenv("MYSQL_HOST")
	dbPort := os.Getenv("MYSQL_PORT")

createDBDsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
	)

for retry < 3 {
		time.Sleep(10 * time.Second)
		database, err = gorm.Open(mysql.Open(createDBDsn), &gorm.Config{})
		if err == nil {
			break
		}
		retry++
	}
	if err != nil {
		fmt.Println(">> ", err.Error(), createDBDsn)
		return nil, err
	}

tx := database.Exec("CREATE DATABASE IF NOT EXISTS " + dbName + ";")
	if tx.Error != nil {
		return nil, tx.Error
	}
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
		dbName,
	)
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	isTable := db.Migrator().HasTable(&Counter{})
	fmt.Println("isTable", isTable)
	err = db.AutoMigrate(&Counter{})
	if err == nil {
		if !isTable {
			db.Create(&Counter{Name: "count", Count: 0})
		}
	}
	return db, nil
}
```

예제 코드 치고는 코드 길이가 제법된다. 중요 부분을 하나씩 떼어내서 살펴보자.
```go
import(
	"github.com/gorilla/mux"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)
```
API 개발을 위해서 **gorilla 웹 툴킷**을 이용했다. gin, Revel 같은 웹 프레임워크에 비교해서 기능은 부족하지만 간단하게 사용 할 수 있어서 널리 사용하고 있다.

데이터베이스를 관리하기 위해서 ORM 라이브러리인 **gorm**을 사용했다. docker-compose로 애플리케이션을 개발 할경우, 데이터베이스 스키마를 만들어줘야 하는데 gorm의 automigration을 이용해서 자동으로 테이블을 생성할 수 있다.

```go
type Counter struct {
	gorm.Model
	Name  string `gorm:"size:16"`
	Count int
}
```

gorm이 사용할 Counter 구조체다. 나중에 gorm은 이 구조체를 기반으로 테이블 스키마를 만들고, 쿼리를 실행한다.

```go
func main() {
	_, err := GetDatabaseInstance()
	if err != nil {
		fmt.Println(">> ", err.Error())
		time.Sleep(2 * time.Second)
		os.Exit(1)
	}

r := mux.NewRouter()
	fmt.Println("Server start!!")
	r.HandleFunc("/api/count", getCounter).Methods("GET")
	r.HandleFunc("/api/count", addCounter).Methods("POST")
	http.ListenAndServe(":8000", r)
}
```

GET /api/count과 POST /api/count 2개의 API를 만들었다.
```go
func addCounter(w http.ResponseWriter, r *http.Request) {
	tx := db.Exec("UPDATE counters SET count=count+1 WHERE name='count'")
	if tx.Error != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w, "Error:%s", tx.Error.Error())
		return
	}
}

```
GET /api/count 과 POST /api/count를 위한 handler 함수다. getCounter는 count 값을 읽어서 리턴하고, addCounter는 count를 1 증가시킨다.

```go
func GetDatabaseInstance() (*gorm.DB, error) {
	var (
		retry    int
		database *gorm.DB
		err      error
	)
	retry = 0
	dbUser := os.Getenv("MYSQL_USER")
	dbPass := os.Getenv("MYSQL_PASSWORD")
	dbName := os.Getenv("MYSQL_DATABASE")
	dbHost := os.Getenv("MYSQL_HOST")
	dbPort := os.Getenv("MYSQL_PORT")

createDBDsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
	)

```
데이터베이스와 관련된 정보를 환경변수를 통해서 관리하기로 했다. 환경변수를 이용해서 관리 하면, 별도의 환경파일을 관리 할 필요가 없고, Docker 컨테이너를 실행할 때, 컨테이너 변수로 데이터베이스 설정 값을 넘길 수 있다는 장점이 있다. 나중에 ECS, Kubernetes 등으로 배포할 때도 환경변수를 이용하여 좀 더 쉽게 배포 할 수 있다.

```go
	for retry < 3 {
		time.Sleep(10 * time.Second)
		database, err = gorm.Open(mysql.Open(createDBDsn), &gorm.Config{})
		if err == nil {
			break
		}
		retry++
	}
	if err != nil {
		fmt.Println(">> ", err.Error(), createDBDsn)
		return nil, err
	}

tx := database.Exec("CREATE DATABASE IF NOT EXISTS " + dbName + ";")
	if tx.Error != nil {
		return nil, tx.Error
	}
```

DB 연결이 끝났다면 "CREATE DATABASE IF NOT EXISTS dbName" 쿼리를 이용해서 **dbName 데이터베이스가 없을 경우** 새로 데이터베이스를 생성하도록 했다.

```go
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true",
		dbUser,
		dbPass,
		dbHost,
		dbPort,
		dbName,
	)
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	isTable := db.Migrator().HasTable(&Counter{})
	fmt.Println("isTable", isTable)
	err = db.AutoMigrate(&Counter{})
	if err == nil {
		if !isTable {
			db.Create(&Counter{Name: "count", Count: 0})
		}
	}
	return db, nil
```
이제 환경 변수 값을 이용해서 dsn 을 만들고 mysql 데이터베이스에 연결한다.

연결하고 나면 **db.Migrator()** 를 호출해서 Counter 구조체를 기반으로 테이블을 마이그레이션 한다. 만약 테이블이 없건나, 테이블 스키마가 변경됐다면 자동으로 테이블을 생성 혹은 변경해준다.

테이블을 새로 만드는 경우 **db.Create**를 호출해서 count 를 0으로 설정한다.

## 예제 코드를 docker 이미지로 만들기
Make가 설치돼 있으면 "make"를 실행하면 된다. 혹은 build 명령을 이용해서 직접 이미지를 만들어도 된다.
```shell
$ docker build -t joinc/counter:0.1 -t joinc/counter:latest .
```
## docker-compose.yml 설정파일
이제 docker-compose.yml 파일을 분석해 보자. 
```yaml
version: "3.0"

networks:
  joinc-nw:

services:
  counter-app:
    image: joinc/counter:latest
    ports:
      - "8000:8000"
    depends_on:
      - counter-db 
    networks:
      - joinc-nw
    environment:
      MYSQL_USER: "root"
      MYSQL_PASSWORD: "1234"
      MYSQL_DATABASE: "counter"
      MYSQL_PORT: "3306"
      MYSQL_HOST: "counter-db"

counter-db:
    image: mysql:latest
    ports:
      - "3306"
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    networks:
      - joinc-nw
```

joinc-nw 를 만들었다. driver를 따로 설정하지 않았는데, 이 경우 bridge driver가 설정된다. 위 설정은 아래와 같이 바꿀 수 있다.
```yaml
networks:
  joinc-nw:
    driver: bridge
```

counter-app 서비스 설정을 보자.
```yml
  counter-app:
    image: joinc/counter:latest
    ports:
      - "8000:8000"
    depends_on:
      - counter-db 
    networks:
      - joinc-nw
    environment:
      MYSQL_USER: "root"
      MYSQL_PASSWORD: "1234"
      MYSQL_DATABASE: "counter"
      MYSQL_PORT: "3306"
      MYSQL_HOST: "counter-db"
```

* image: joinc/counter:latest 이미지로 컨테이너를 만든다. 
* ports: 8000 번 포트로 포트포워딩 했다. 
* depends_on: counter-mysql 컨테이너가 실행되고 나면, 실행한다. 
* networks: joinc-nw 네트워크를 사용한다.
* environment: 컨테이너가 시작될 때 설정될 환경 변수들이다. Go 애플리케이션은 이 환경변수를 읽어서 데이터베이스에 연결할 수 있다. **MYSQL_HOST**는 데이터베이스 서버의 이름인데, services 블록의 서비스 이름 "counter-db"으로 서버를 찾을 수 있다.

MySQL 데이터베이스의 service 블록 정보를 보자.
```yml
  counter-db:
    image: mysql:latest
    ports:
      - "3306"
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    networks:
      - joinc-nw
```
* image: mysql 최신 이미지로 컨테이너를 실행한다.
* ports: mysql의 기본 포트 3306을 사용한다.
* envorionment: MySQL 서버의 root 패스워드를 설정한다.
* networks: joinc-nw를 사용한다.

## docker-compose 실행
docker-compose up 명령으로 애플리케이션을 실행해보자.
```
$ docker-compose up   
[+] Running 2/0
 ✔ Container docker-compose-counter-db-1   Created        0.0s 
 ✔ Container docker-compose-counter-app-1  Recreated      0.0s 
Attaching to docker-compose-counter-app-1, docker-compose-counter-db-1
```

docker-compose ps 명령으로 컨테이너를 확인해 보자.
![docker-compose ps](https://docs.google.com/drawings/d/e/2PACX-1vQQ8quCJkg8glC0fDqS_T2Hq9Tz-LmTHcYJe4qYGtbWsC6PDuBuBHlY2ERuhsofcrfF3WEW0fSLVAdk/pub?w=1409&h=100)

curl 을 이용해서 GET /api/count 와 POST /api/count가 잘 작동하는지 테스트해보자.
```
$ curl localhost:8000/api/count
0
$ curl -XPOST localhost:8000/api/count
$ curl localhost:8000/api/count
1
```
잘 작동하는 걸 확인할 수 있다.

## 정리
이 문서에서 실행한 docker-compose 애플리케이션 아키텍처는 아래와 같이 묘사할 수 있을 것이다.
![docker-compose 애플리케이션 아키텍처](https://docs.google.com/drawings/d/e/2PACX-1vSNSuARywTVY87ryNVwEsYt3VrdW95Ow7aHixvr8dQPqhqo3ZOxskZnIIKZ1ZRew-0stFArfYkADDQA/pub?w=624&h=221)
services는 **counter-app** 과 **docunter-db** 컨테이너로 구성된다. 이들 컨테이너는 **joinc-nw**로 서로 연결된다. 각 컨테이너는 IP가 아닌 service name 으로 찾을 수 있기 때문에 IP를 설정할 필요가 없다.

조금 더 부지런하면 [minikube](https://www.joinc.co.kr/w/kubernetes_minikube_index)로 구축할 수도 있는데, 개발 팀이 minikube를 이용해서 개발환경을 구축하는 것은 너무 복잡하다. docker-compose를 검토해 보자.

Search For:

BY TAGS

소개

조건

애플리케이션 아키텍처

GoLang 애플리케이션

예제 코드를 docker 이미지로 만들기

docker-compose.yml 설정파일

docker-compose 실행

정리

Recent Posts

Archive Posts

Tags

About

Get in Touch

Categories

Search For:

BY TAGS

Golang Application을 docker compose로 개발하기

소개

조건

애플리케이션 아키텍처

GoLang 애플리케이션

예제 코드를 docker 이미지로 만들기

docker-compose.yml 설정파일

docker-compose 실행

정리

Recent Posts

Archive Posts

Tags

About

Get in Touch

Categories

Subscribe