Golang 서비스를 위한 DB 마이그레이션, 왜 중요한가요?

DB 마이그레이션, 왜 중요한가요?

업데이트된 데이터베이스 스키마를 사용하여 프로덕션에 새 업데이트를 배포했지만 이후 버그가 발생하여 되돌려야 하는 상황에 직면한 적이 있습니까?... 이때 마이그레이션이 시작됩니다.

데이터베이스 마이그레이션은 몇 가지 주요 목적으로 사용됩니다.

1. 스키마 진화: 애플리케이션이 발전함에 따라 데이터 모델도 변경됩니다. 마이그레이션을 통해 개발자는 이러한 변경 사항을 반영하도록 데이터베이스 스키마를 체계적으로 업데이트하여 데이터베이스 구조가 애플리케이션 코드와 일치하도록 할 수 있습니다.
2. 버전 제어: 마이그레이션은 데이터베이스 스키마 버전을 지정하는 방법을 제공하여 팀이 시간 경과에 따른 변경 사항을 추적할 수 있도록 합니다. 이 버전 관리는 데이터베이스의 발전을 이해하는 데 도움이 되며 개발자 간의 협업에 도움이 됩니다.
3. 환경 간 일관성: 마이그레이션을 통해 데이터베이스 스키마가 다양한 환경(개발, 테스트, 프로덕션)에서 일관되게 유지됩니다. 이렇게 하면 버그 및 통합 문제로 이어질 수 있는 불일치의 위험이 줄어듭니다.
4. 롤백 기능: 많은 마이그레이션 도구는 변경 사항 롤백을 지원하므로 개발자는 마이그레이션으로 인해 문제가 발생할 경우 데이터베이스의 이전 상태로 되돌릴 수 있습니다. 이를 통해 개발 및 배포 과정에서 안정성이 향상됩니다.
5. 자동 배포: 배포 프로세스의 일부로 마이그레이션을 자동화하여 수동 개입 없이 필요한 스키마 변경 사항이 데이터베이스에 적용되도록 할 수 있습니다. 이를 통해 릴리스 프로세스가 간소화되고 인적 오류가 줄어듭니다.

golang 프로젝트에 적용하기

쉬운 마이그레이션, 업데이트 및 롤백을 허용하는 MySQL과 GORM을 사용하여 Golang 서비스에 대한 포괄적인 프로덕션 등급 설정을 생성하려면 마이그레이션 도구를 포함하고, 데이터베이스 연결 풀링을 처리하고, 적절한 구조 정의를 보장해야 합니다. 다음은 프로세스를 안내하는 전체 예입니다.

프로젝트 구조

/golang-service
|-- main.go
|-- database
|   |-- migration.go
|-- models
|   |-- user.go
|-- config
|   |-- config.go
|-- migrations
|   |-- ...
|-- go.mod

1. 데이터베이스 구성(config/config.go)

package config

import (
    "fmt"
    "log"
    "os"
    "time"

    "github.com/joho/godotenv"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

var DB *gorm.DB

func ConnectDB() {
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }

    // charset=utf8mb4: Sets the character set to utf8mb4, which supports all Unicode characters, including emojis.
    // parseTime=True: Tells the driver to automatically parse DATE and DATETIME values into Go's time.Time type.
    // loc=Local: Uses the local timezone of the server for time-related queries and storage.
    dsn := fmt.Sprintf(
        "%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
        os.Getenv("DB_USER"),
        os.Getenv("DB_PASS"),
        os.Getenv("DB_HOST"),
        os.Getenv("DB_PORT"),
        os.Getenv("DB_NAME"),
    )

    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    sqlDB, err := db.DB()
    if err != nil {
        panic("failed to configure database connection")
    }

    // Set connection pool settings
    sqlDB.SetMaxIdleConns(10)
    sqlDB.SetMaxOpenConns(100)
    sqlDB.SetConnMaxLifetime(time.Hour)

    // 1.sqlDB.SetMaxIdleConns(10)
    // Sets the maximum number of idle (unused but open) connections in the connection pool.
    // A value of 10 means up to 10 connections can remain idle, ready to be reused.

    // 2. sqlDB.SetMaxOpenConns(100):
    // Sets the maximum number of open (active or idle) connections that can be created to the database.
    // A value of 100 limits the total number of connections, helping to prevent overloading the database.

    // 3. sqlDB.SetConnMaxLifetime(time.Hour):
    // Sets the maximum amount of time a connection can be reused before it’s closed.
    // A value of time.Hour means that each connection will be kept for up to 1 hour, after which it will be discarded and a new connection will be created if needed.

    DB = db
}

2. 데이터베이스 마이그레이션(database/migration.go)

package database

import (
    "golang-service/models"
    "golang-service/migrations"
    "gorm.io/gorm"
)

func Migrate(db *gorm.DB) {
    db.AutoMigrate(&models.User{})
    // Apply additional custom migrations if needed
}

3. 모델(models/user.go)

package models

import "gorm.io/gorm"

type User struct {
    gorm.Model
    Name  string `json:"name"`
}

4. 환경 구성(.env)

DB_USER=root
DB_PASS=yourpassword
DB_HOST=127.0.0.1
DB_PORT=3306
DB_NAME=yourdb

5. 메인 진입점 (main.go)

package main

import (
    "golang-service/config"
    "golang-service/database"
    "golang-service/models"
    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
)

func main() {
    config.ConnectDB()
    database.Migrate(config.DB)

    r := gin.Default()
    r.POST("/users", createUser)
    r.GET("/users/:id", getUser)
    r.Run(":8080")
}

func createUser(c *gin.Context) {
    var user models.User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }

    if err := config.DB.Create(&user).Error; err != nil {
        c.JSON(500, gin.H{"error": err.Error()})
        return
    }

    c.JSON(201, user)
}

func getUser(c *gin.Context) {
    id := c.Param("id")
    var user models.User

    if err := config.DB.First(&user, id).Error; err != nil {
        c.JSON(404, gin.H{"error": "User not found"})
        return
    }

    c.JSON(200, user)
}

6. 설명:

• 데이터베이스 구성: 프로덕션급 성능을 위해 연결 풀링을 관리합니다.
• 마이그레이션 파일: (마이그레이션 폴더에 있음) 데이터베이스 스키마 버전 관리에 도움이 됩니다.
• GORM 모델: 데이터베이스 테이블을 Go 구조체에 매핑합니다.
• 데이터베이스 마이그레이션: (데이터베이스 폴더에 있음) 시간이 지남에 따라 테이블을 변경하는 사용자 정의 논리로 쉽게 롤백할 수 있습니다.
• 테스트: httptest 및 testify를 사용하여 이 설정에 대한 통합 테스트를 생성할 수 있습니다.

7. 첫 번째 마이그레이션 생성

1. 프로덕션 환경의 경우 golang- migration과 같은 마이그레이션 라이브러리를 사용하여 마이그레이션을 적용, 롤백 또는 다시 실행할 수 있습니다.

   golang-migrate 설치:
   

   go install -tags 'mysql' github.com/golang-migrate/migrate/v4/cmd/migrate@latest
   

2. 사용자 테이블에 대한 마이그레이션 파일 생성
   

   migrate create -ext=sql -dir=./migrations -seq create_users_table
   

   명령을 실행하면 .up.sql(스키마 업데이트용)과 down.sql(나중에 잠재적인 롤백용) 쌍이 생성됩니다. 숫자 000001은 자동 생성된 마이그레이션 인덱스입니다.
   

   /golang-service
   |-- migrations
   |   |-- 000001_create_users_table.down.sql
   |   |-- 000001_create_users_table.up.sql
   

   해당 sql 명령을 .up 파일, .down 파일에 추가합니다.

   000001_create_users_table.up.sql
   

   CREATE TABLE users (
   id BIGINT AUTO_INCREMENT PRIMARY KEY,
   name VARCHAR(255) NOT NULL,
   created_at DATETIME,
   updated_at DATETIME,
   deleted_at DATETIME);
   

   000001_create_users_table.down.sql
   

   DROP TABLE IF EXISTS users;
   

   업 마이그레이션을 실행하고 다음 명령을 사용하여 데이터베이스에 변경 사항을 적용합니다(자세한 로그 세부 정보를 보려면 -verbose 플래그).
   

   migrate -path ./migrations -database "mysql://user:password@tcp(localhost:3306)/dbname" -verbose up
   

   마이그레이션 문제가 발생한 경우 다음 명령을 사용하여 현재 마이그레이션 버전과 상태를 확인할 수 있습니다.
   

   migrate -path ./migrations -database "mysql://user:password@tcp(localhost:3306)/dbname" version
   

   어떤 이유로 마이그레이션이 중단된 경우 더티 마이그레이션 버전 번호와 함께 강제(신중하게 사용) 명령을 사용하는 것을 고려할 수 있습니다. 버전이 1인 경우(migrations 또는 Schema_migrations 테이블에서 확인할 수 있음) 다음을 실행합니다.
   

   migrate -path ./migrations -database "mysql://user:password@tcp(localhost:3306)/dbname" force 1
   

8. 계획 변경

1. 언젠가는 새로운 기능을 추가하고 싶을 수도 있고 그 중 일부에는 데이터 구성표 변경이 필요할 수도 있습니다. 예를 들어 사용자 테이블에 이메일 필드를 추가하고 싶을 수도 있습니다. 다음과 같이 하겠습니다.

   사용자 테이블에 이메일 열을 추가하기 위해 새로운 마이그레이션을 수행하세요
   

   migrate create -ext=sql -dir=./migrations -seq add_email_to_users
   

   이제 새로운 .up.sql과 .down.sql 쌍이 생겼습니다
   

   /golang-service
   |-- migrations
   |   |-- 000001_create_users_table.down.sql
   |   |-- 000001_create_users_table.up.sql
   |   |-- 000002_add_email_to_users.down.sql
   |   |-- 000002_add_email_to_users.up.sql
   

2. *_add_email_to_users.*.sql 파일

   에 다음 콘텐츠 추가

   000002_add_email_to_users.up.sql
   

   /golang-service
   |-- main.go
   |-- database
   |   |-- migration.go
   |-- models
   |   |-- user.go
   |-- config
   |   |-- config.go
   |-- migrations
   |   |-- ...
   |-- go.mod
   
   

   000002_add_email_to_users.down.sql
   

   package config
   
   import (
       "fmt"
       "log"
       "os"
       "time"
   
       "github.com/joho/godotenv"
       "gorm.io/driver/mysql"
       "gorm.io/gorm"
   )
   
   var DB *gorm.DB
   
   func ConnectDB() {
       err := godotenv.Load()
       if err != nil {
           log.Fatal("Error loading .env file")
       }
   
       // charset=utf8mb4: Sets the character set to utf8mb4, which supports all Unicode characters, including emojis.
       // parseTime=True: Tells the driver to automatically parse DATE and DATETIME values into Go's time.Time type.
       // loc=Local: Uses the local timezone of the server for time-related queries and storage.
       dsn := fmt.Sprintf(
           "%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
           os.Getenv("DB_USER"),
           os.Getenv("DB_PASS"),
           os.Getenv("DB_HOST"),
           os.Getenv("DB_PORT"),
           os.Getenv("DB_NAME"),
       )
   
       db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
       if err != nil {
           panic("failed to connect database")
       }
   
       sqlDB, err := db.DB()
       if err != nil {
           panic("failed to configure database connection")
       }
   
       // Set connection pool settings
       sqlDB.SetMaxIdleConns(10)
       sqlDB.SetMaxOpenConns(100)
       sqlDB.SetConnMaxLifetime(time.Hour)
   
       // 1.sqlDB.SetMaxIdleConns(10)
       // Sets the maximum number of idle (unused but open) connections in the connection pool.
       // A value of 10 means up to 10 connections can remain idle, ready to be reused.
   
       // 2. sqlDB.SetMaxOpenConns(100):
       // Sets the maximum number of open (active or idle) connections that can be created to the database.
       // A value of 100 limits the total number of connections, helping to prevent overloading the database.
   
       // 3. sqlDB.SetConnMaxLifetime(time.Hour):
       // Sets the maximum amount of time a connection can be reused before it’s closed.
       // A value of time.Hour means that each connection will be kept for up to 1 hour, after which it will be discarded and a new connection will be created if needed.
   
       DB = db
   }
   
   

   up migration 명령을 다시 실행하여 데이터 스키마를 업데이트하세요
   

   package database
   
   import (
       "golang-service/models"
       "golang-service/migrations"
       "gorm.io/gorm"
   )
   
   func Migrate(db *gorm.DB) {
       db.AutoMigrate(&models.User{})
       // Apply additional custom migrations if needed
   }
   
   

   또한 새로운 스키마와 동기화를 유지하려면 golang 사용자 구조체를 업데이트해야 합니다(Email 필드 추가).
   

   package models
   
   import "gorm.io/gorm"
   
   type User struct {
       gorm.Model
       Name  string `json:"name"`
   }
   
   

9. 마이그레이션 롤백:

어떤 이유로 새로 업데이트된 스키마에 버그가 있어 롤백해야 하는 경우에는 down 명령을 사용합니다.

DB_USER=root
DB_PASS=yourpassword
DB_HOST=127.0.0.1
DB_PORT=3306
DB_NAME=yourdb

숫자 1은 마이그레이션 1개를 롤백하겠다는 의미입니다.

여기서 데이터 스키마 변경 사항을 반영하려면 golang 사용자 구조체를 수동으로 업데이트해야 합니다(Email 필드 제거).

package main

import (
    "golang-service/config"
    "golang-service/database"
    "golang-service/models"
    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
)

func main() {
    config.ConnectDB()
    database.Migrate(config.DB)

    r := gin.Default()
    r.POST("/users", createUser)
    r.GET("/users/:id", getUser)
    r.Run(":8080")
}

func createUser(c *gin.Context) {
    var user models.User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }

    if err := config.DB.Create(&user).Error; err != nil {
        c.JSON(500, gin.H{"error": err.Error()})
        return
    }

    c.JSON(201, user)
}

func getUser(c *gin.Context) {
    id := c.Param("id")
    var user models.User

    if err := config.DB.First(&user, id).Error; err != nil {
        c.JSON(404, gin.H{"error": "User not found"})
        return
    }

    c.JSON(200, user)
}

10. Makefile과 함께 사용

마이그레이션 및 롤백 프로세스를 단순화하기 위해 Makefile을 추가할 수 있습니다.

go install -tags 'mysql' github.com/golang-migrate/migrate/v4/cmd/migrate@latest

Makefile의 내용은 다음과 같습니다.

migrate create -ext=sql -dir=./migrations -seq create_users_table

이제 CLI에서 make migration_up 또는 make migration_down을 실행하여 마이그레이션과 롤백을 수행할 수 있습니다.

11.고려사항:

• 롤백 중 데이터 손실: 열이나 테이블을 삭제하는 마이그레이션을 롤백하면 데이터가 손실될 수 있으므로 롤백을 실행하기 전에 항상 데이터를 백업하세요.
• CI/CD 통합: 마이그레이션 프로세스를 CI/CD 파이프라인에 통합하여 배포 중 스키마 변경을 자동화합니다.
• DB 백업: 마이그레이션 오류 발생 시 데이터 손실을 방지하기 위해 정기적인 데이터베이스 백업을 예약하세요.

DB 백업 정보

마이그레이션을 롤백하거나 데이터베이스에 잠재적으로 영향을 미칠 수 있는 변경을 하기 전에 고려해야 할 몇 가지 주요 사항은 다음과 같습니다.

1. 스키마 변경: 마이그레이션에 스키마 변경(예: 열 추가 또는 제거, 데이터 유형 변경)이 포함된 경우, 이전 마이그레이션으로 롤백하면 변경된 열이나 테이블에 저장된 모든 데이터가 손실될 수 있습니다. .
2. 데이터 제거: 마이그레이션에 데이터를 삭제하는 명령(예: 테이블 삭제 또는 테이블 자르기)이 포함된 경우 롤백하면 해당 "다운" 마이그레이션이 실행되어 해당 데이터가 영구적으로 제거될 수 있습니다.
3. 트랜잭션 처리: 마이그레이션 도구가 트랜잭션을 지원하는 경우 변경 사항이 트랜잭션에 적용되므로 롤백이 더 안전할 수 있습니다. 그러나 트랜잭션 외부에서 SQL 명령을 수동으로 실행하는 경우 데이터가 손실될 위험이 있습니다.
4. 데이터 무결성: 현재 스키마에 따라 데이터를 수정한 경우 롤백하면 데이터베이스가 일관되지 않은 상태가 될 수 있습니다.

따라서 데이터를 백업하는 것이 중요합니다. 간략한 안내는 다음과 같습니다.

1. 데이터베이스 덤프:
   데이터베이스 관련 도구를 사용하여 데이터베이스의 전체 백업을 생성합니다. MySQL의 경우 다음을 사용할 수 있습니다.
   

   /golang-service
   |-- main.go
   |-- database
   |   |-- migration.go
   |-- models
   |   |-- user.go
   |-- config
   |   |-- config.go
   |-- migrations
   |   |-- ...
   |-- go.mod
   
   

   이렇게 하면 dbname 데이터베이스의 모든 데이터와 스키마가 포함된 파일(backup_before_rollback.sql)이 생성됩니다.

2. 특정 테이블 내보내기:
   특정 테이블만 백업해야 하는 경우 mysqldump 명령에 해당 테이블을 지정하세요.
   

   package config
   
   import (
       "fmt"
       "log"
       "os"
       "time"
   
       "github.com/joho/godotenv"
       "gorm.io/driver/mysql"
       "gorm.io/gorm"
   )
   
   var DB *gorm.DB
   
   func ConnectDB() {
       err := godotenv.Load()
       if err != nil {
           log.Fatal("Error loading .env file")
       }
   
       // charset=utf8mb4: Sets the character set to utf8mb4, which supports all Unicode characters, including emojis.
       // parseTime=True: Tells the driver to automatically parse DATE and DATETIME values into Go's time.Time type.
       // loc=Local: Uses the local timezone of the server for time-related queries and storage.
       dsn := fmt.Sprintf(
           "%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
           os.Getenv("DB_USER"),
           os.Getenv("DB_PASS"),
           os.Getenv("DB_HOST"),
           os.Getenv("DB_PORT"),
           os.Getenv("DB_NAME"),
       )
   
       db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
       if err != nil {
           panic("failed to connect database")
       }
   
       sqlDB, err := db.DB()
       if err != nil {
           panic("failed to configure database connection")
       }
   
       // Set connection pool settings
       sqlDB.SetMaxIdleConns(10)
       sqlDB.SetMaxOpenConns(100)
       sqlDB.SetConnMaxLifetime(time.Hour)
   
       // 1.sqlDB.SetMaxIdleConns(10)
       // Sets the maximum number of idle (unused but open) connections in the connection pool.
       // A value of 10 means up to 10 connections can remain idle, ready to be reused.
   
       // 2. sqlDB.SetMaxOpenConns(100):
       // Sets the maximum number of open (active or idle) connections that can be created to the database.
       // A value of 100 limits the total number of connections, helping to prevent overloading the database.
   
       // 3. sqlDB.SetConnMaxLifetime(time.Hour):
       // Sets the maximum amount of time a connection can be reused before it’s closed.
       // A value of time.Hour means that each connection will be kept for up to 1 hour, after which it will be discarded and a new connection will be created if needed.
   
       DB = db
   }
   
   

3. 백업 확인:
   백업 파일이 생성되었는지 확인하고 크기를 확인하거나 파일을 열어 필요한 데이터가 포함되어 있는지 확인하세요.

4. 백업을 안전하게 저장:
   롤백 과정 중 데이터 손실을 방지하기 위해 클라우드 스토리지나 별도 서버 등 안전한 위치에 백업 복사본을 보관하세요.

클라우드 백업

Golang을 사용하고 AWS EKS에 배포할 때 MySQL 데이터를 백업하려면 다음 단계를 따르세요.

1. 데이터베이스 백업에 mysqldump 사용:
   Kubernetes cron 작업을 사용하여 MySQL 데이터베이스의 mysqldump를 생성하세요.
   

   package database
   
   import (
       "golang-service/models"
       "golang-service/migrations"
       "gorm.io/gorm"
   )
   
   func Migrate(db *gorm.DB) {
       db.AutoMigrate(&models.User{})
       // Apply additional custom migrations if needed
   }
   
   

   영구 볼륨이나 S3 버킷에 저장하세요.

2. Kubernetes CronJob으로 자동화:
   Kubernetes CronJob을 사용하여 mysqldump 프로세스를 자동화하세요.
   YAML 구성 예:yaml
   

   package models
   
   import "gorm.io/gorm"
   
   type User struct {
       gorm.Model
       Name  string `json:"name"`
   }
   
   

   
   `

3. AWS RDS 자동 백업 사용(RDS를 사용하는 경우):
   MySQL 데이터베이스가 AWS RDS에 있는 경우 RDS 자동 백업 및 스냅샷
   을 활용할 수 있습니다. 백업 보존 기간을 설정하고 수동으로 스냅샷을 찍거나 Lambda 기능을 사용하여 스냅샷을 자동화하세요.

4. Velero를 사용하여 영구 볼륨(PV) 백업:
   Kubernetes용 백업 도구인 Velero를 사용하여 MySQL 데이터를 보관하는 영구 볼륨을 백업하세요.
   EKS 클러스터에 Velero를 설치하고 S3에 백업하도록 구성합니다.

이러한 방법을 사용하면 MySQL 데이터를 정기적으로 백업하고 안전하게 저장할 수 있습니다.

위 내용은 Golang 서비스를 위한 DB 마이그레이션, 왜 중요한가요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!