Docker를 사용하여 Go 애플리케이션을 배포하는 방법

Docker는 애플리케이션의 패키징, 배포, 배포를 단순화하는 컨테이너화 플랫폼입니다. Go와 Docker의 이점을 활용하여 애플리케이션의 효율성, 이식성 및 보안을 강화할 수 있습니다.

이 튜토리얼은 Docker를 사용하여 Go 애플리케이션을 구축하고 배포하는 방법을 가르치는 데 투자되었습니다. 컨테이너화하고 배포할 Gorilla Mux 및 GORM 패키지로 RESTful API를 구축하여 학습하게 됩니다.

1단계: 개발 환경 설정

Docker로 Go 앱을 구축하고 컨테이너화하려면 컴퓨터에 Go와 Docker가 설치되어 있어야 합니다.

시스템에 Go 및 Docker가 설치되어 있는지 확인하세요. Go 공식 다운로드 웹사이트에서 Go를 다운로드하고 Docker Hub에서 Docker를 다운로드할 수 있습니다. 아직 웹페이지를 방문하지 않은 경우 해당 운영 체제에 대한 설치 지침을 따르세요.

이 문서에서는 Docker를 사용하여 Go 앱을 배포하는 방법을 설명하고 Go 애플리케이션 컨테이너화를 포함하여 Docker 및 Postgres 데이터베이스 설치 및 설정에 대해 자세히 설명합니다.

설치 후 필요에 따라 환경 변수와 경로를 설정하여 Go 개발 환경을 구성하세요. 필요한 디렉터리 구조를 갖춘 작동 중인 Go 작업 공간이 있는지 확인하세요.

또한 Docker의 명령줄 인터페이스(CLI)와 기본 Docker 개념을 익힐 수 있습니다.

이 프로젝트에 대한 새 디렉터리를 생성하고 go mod init 명령을 실행하여 해당 디렉터리를 Go 프로젝트로 초기화하세요.

go mod init

Go 프로젝트를 초기화한 후 이 명령을 실행하여 GORM 및 Gorilla Mux 패키지를 프로젝트에 종속성으로 추가하세요.

go get github.com/gorilla/mux

go get gorm.io/gorm
go get gorm.io/driver/postgres

라우팅에는 Gorilla Mux 패키지를 사용합니다. GORM 패키지는 설치된 드라이버 패키지(이 경우 Postgres)와 함께 SQL 데이터베이스 작업에 Go 유형을 사용할 수 있는 인터페이스를 제공합니다.

2단계: Go 애플리케이션 구축

이 튜토리얼에서는 인기 있는 Go 계층 아키텍처 스타일을 사용하고 인터페이스를 사용하여 앱의 다양한 구성 요소와 상호 작용합니다.

애플리케이션의 디렉토리 구조는 다음과 같습니다.

go mod init

1. Dockerfile: Dockerfile은 Docker 이미지를 빌드하기 위한 구성 파일입니다. API를 기반으로 이 파일의 내용을 작성하게 됩니다.
2. cmd: cmd 디렉토리에는 일반적으로 애플리케이션의 진입점이 포함됩니다. 서버 하위 디렉터리는 API 서버가 프로젝트의 주요 구성 요소임을 나타냅니다. cmd/server의 main.go 파일에는 애플리케이션의 진입점이 포함되어 있습니다.
3. internal: 내부 디렉터리는 애플리케이션의 내부 패키지를 구성하는 데 도움이 됩니다. 내부 패키지는 내보내면 안 되므로 구현 세부 정보를 숨기기에 좋은 장소입니다.
   • http: 이 하위 디렉토리에는 경로 핸들러 및 API용 미들웨어를 포함한 HTTP 관련 코드가 포함됩니다.
     • handlers.go: 이 파일에 HTTP 요청 핸들러가 포함됩니다.
     • users.go: 여기에서 사용자 관리와 관련된 HTTP 핸들러를 지정합니다.
   • models: 이 디렉토리에는 데이터베이스 관련 코드와 데이터 모델이 포함됩니다.
   • database.go: 이 파일에는 데이터베이스 초기화 및 연결을 위한 코드가 포함되어 있습니다.
   • migrations.go: 이 파일은 데이터베이스 스키마 마이그레이션을 처리하여 데이터베이스 스키마가 애플리케이션 요구 사항과 일치하는지 확인합니다.
   • users.go: 이 파일에는 데이터베이스와 상호 작용하는 사용자와 관련된 데이터 모델 또는 구조체 정의가 있습니다.
   • users: 이 디렉터리에는 사용자별 논리가 포함됩니다.
     • user.go: 이 파일에는 데이터베이스 구현과 상호 작용하는 사용자 관리와 관련된 기능 및 구조가 포함되어 있습니다. HTTP 구현은 여기의 기능과 상호 작용합니다.

이 프로젝트 구조는 잘 조직되어 있어 서로 다른 구성 요소 간의 문제를 명확하게 구분합니다. 이 조직을 사용하면 Go API가 성장함에 따라 더 쉽게 유지 관리하고 확장할 수 있습니다.

이것은 Go 표준이 아닙니다. 그러나 많은 Go 개발자와 오픈 소스 프로젝트에서는 애플리케이션에 이 구조를 사용합니다.

2a단계: 데이터베이스 구현 작성

애플리케이션에 대한 데이터베이스 기능을 설정하게 됩니다. 구조체를 사용하여 모델을 정의하고, 데이터베이스에 연결하고, 데이터베이스에 삽입 작업을 위한 마이그레이션을 설정해야 합니다.

데이터베이스 구현에 필요한 가져오기 목록은 다음과 같습니다.

go get github.com/gorilla/mux

go get gorm.io/gorm
go get gorm.io/driver/postgres

첫 번째 작업은 앱의 데이터베이스 스키마와 일치하는 Strut를 정의하는 것입니다. GORM은 필드에 대한 추가 옵션 및 제약 조건을 지정하기 위한 태그를 제공합니다.

.
├── Dockerfile
├── cmd
│   └── server
│       └── main.go
└── internal
    ├── http
    │   ├── handlers.go
    │   └── users.go
    ├── models
    │   ├── database.go
    │   ├── migrations.go
    │   └── users.go
    └── users
        └── user.go

6 directories, 11 files

User 구조체는 데이터베이스에서 사용자 데이터로 작업하기 위한 모델을 나타냅니다.

database.go 파일에서 데이터베이스 연결 인스턴스를 캡슐화하는 구조체를 선언하세요. 이 구조체를 사용하여 데이터베이스 구현 패키지의 다른 부분에서 데이터베이스에 연결하게 됩니다.

go mod init

다음으로 데이터베이스 구현을 데이터베이스 프로그램에 연결하는 데이터베이스 연결 기능을 만듭니다.

go get github.com/gorilla/mux

go get gorm.io/gorm
go get gorm.io/driver/postgres

NewDatabase 함수는 새 데이터베이스 인스턴스를 생성하고 데이터베이스에 대한 연결을 설정합니다. 데이터베이스 인스턴스에 대한 포인터를 반환하며, 프로세스 중에 오류가 있는 경우 오류가 발생합니다.

데이터베이스 연결이 성공적으로 완료되면 다음 기능을 사용하여 데이터베이스 구현을 위한 마이그레이션 기능을 설정할 수 있습니다.

.
├── Dockerfile
├── cmd
│   └── server
│       └── main.go
└── internal
    ├── http
    │   ├── handlers.go
    │   └── users.go
    ├── models
    │   ├── database.go
    │   ├── migrations.go
    │   └── users.go
    └── users
        └── user.go

6 directories, 11 files

MgrateDB 함수는 데이터베이스 클라이언트 AutoMigrate 함수를 사용하여 사용자 구조체에 대한 자동 마이그레이션을 설정하고 프로세스 중에 오류가 발생하면 오류를 반환합니다.

2b단계: 데이터베이스 구현을 위한 기능 정의

데이터베이스 스키마의 구조체를 정의한 users.go 파일에서 데이터베이스 구현을 위한 함수 정의를 진행할 수 있습니다.

다음은 데이터베이스에서 CRUD 작업을 담당하는 CreateUser, GetUserByID, UpdateUser 및 DeleteUser 함수입니다.

package models

import (
    // imports from the user implementation
    "BetterApp/internal/users"

    "context"
    "gorm.io/gorm"
    "fmt"
    "gorm.io/driver/postgres"
    "gorm.io/gorm/schema"
    "os"
)

사용자 구현에서는 이러한 함수를 호출하여 데이터베이스 기능에 액세스합니다.

2c단계: 사용자 구현 작성

사용자 구현은 데이터베이스에서 HTTP 구현으로 데이터를 전달하는 데 중요한 역할을 합니다.

데이터베이스 구현의 구조체와 일치하는 구조체를 정의하고 사용할 필드에 JSON 태그를 추가합니다. 그런 다음 HTTP 구현의 데이터로 데이터베이스 함수를 호출하는 함수를 정의합니다.

사용자 구현에 필요한 가져오기는 다음과 같습니다.

// internal/models/users.go

type User struct {
    gorm.Model
    Username string `gorm:"unique;not null"`
    Email    string `gorm:"unique;not null"`
    IsActive bool   `gorm:"not null"`
}

JSON 태그를 사용한 구조는 다음과 같습니다. gorm.Model 필드의 json:"-"은 해당 필드를 JSON 작업에서 제외하도록 지정합니다.

// internal/models/database.go

type Database struct {
    Client *gorm.DB
}

다음으로, 사용자 구현 함수를 위한 메소드, 사용자 구현을 위한 서비스 구조체, 서비스 구현을 초기화하는 함수가 포함된 인터페이스를 선언합니다.

// internal/models/database.go

func NewDatabase() (*Database, error) {

    // Construct a connection string using environment variables for database configuration.
    configurations := fmt.Sprintf("host=%v port=%v user=%v password=%v dbname=%v sslmode=%v",
        os.Getenv("DB_HOST"), os.Getenv("DB_PORT"), os.Getenv("DB_USERNAME"),
        os.Getenv("DB_PASSWORD"), os.Getenv("DB_NAME"), os.Getenv("SSL_MODE"))

    // Open a connection to the database using GORM and PostgreSQL driver.
    db, err := gorm.Open(postgres.New(postgres.Config{
        DSN:                  configurations,
        PreferSimpleProtocol: true,
    }), &gorm.Config{NamingStrategy: schema.NamingStrategy{
        SingularTable: true,
    }})
    if err != nil {
        return nil, err
    }

    // Enable connection pooling by configuring maximum idle and open connections.
    sqlDB, err := db.DB()
    if err != nil {
        return nil, err
    }
    sqlDB.SetMaxIdleConns(10)
    sqlDB.SetMaxOpenConns(100)

    // Return the Database instance with the established database connection.
    return &Database{
        Client: db,
    }, nil
}

인터페이스와 서비스는 사용자 구현 외부에서 사용자 관련 작업을 관리하는 데 도움이 됩니다.

다음으로 데이터베이스 구현을 호출하는 UserService 구조체 구현의 메서드를 정의할 수 있습니다.

// internal/models/migrations.go

func (d *Database) MigrateDB() error {
    log.Println("Database Migration in Process...")

    // Use GORM AutoMigrate to migrate all the database schemas.
    err := d.Client.AutoMigrate(&User{})
    if err != nil {
        return err
    }

    log.Println("Database Migration Complete!")
    return nil
}

CreateUser, GetUserByID, UpdateUser 및 DeleteUser 함수는 데이터베이스 구현에서 CRUD 작업을 호출하는 역할을 합니다. HTTP 구현은 데이터베이스에 액세스하기 위해 이러한 함수를 호출합니다.

2c단계: HTTP 구현 작성

HTTP 구현은 들어오는 요청을 수신하고 상호 작용하는 애플리케이션의 일부입니다.

HTTP 구현 전반에 걸쳐 필요한 가져오기 목록은 다음과 같습니다.

go mod init

먼저 구조체를 선언하고 라우터 인스턴스, HTTP 인스턴스 및 사용자 서비스 인스턴스를 포함합니다.

go get github.com/gorilla/mux

go get gorm.io/gorm
go get gorm.io/driver/postgres

그런 다음 서버와 핸들러를 구성할 수 있는 Handler 구조체에 대한 포인터를 반환하는 함수를 만듭니다.

.
├── Dockerfile
├── cmd
│   └── server
│       └── main.go
└── internal
    ├── http
    │   ├── handlers.go
    │   └── users.go
    ├── models
    │   ├── database.go
    │   ├── migrations.go
    │   └── users.go
    └── users
        └── user.go

6 directories, 11 files

NewHandler 기능은 HTTP 요청 핸들러를 설정 및 구성하여 서버 설정 및 경로를 정의하는 동시에 특정 서비스에 대한 수신 HTTP 요청을 처리할 수 있도록 준비합니다.

NewHandler 함수에서 호출한 mapRoutes 함수는 해당 핸들러 함수에 경로를 매핑하여 경로를 설정합니다.

package models

import (
    // imports from the user implementation
    "BetterApp/internal/users"

    "context"
    "gorm.io/gorm"
    "fmt"
    "gorm.io/driver/postgres"
    "gorm.io/gorm/schema"
    "os"
)

다음으로 핸들러 기능과 해당 기능을 정의합니다. HTTP 요청을 가로채고 작업에 따라 응답하는 역할을 담당하는 CreateUser, GetUserByID, UpdateUser 및 DeleteUser 함수는 다음과 같습니다.

// internal/models/users.go

type User struct {
    gorm.Model
    Username string `gorm:"unique;not null"`
    Email    string `gorm:"unique;not null"`
    IsActive bool   `gorm:"not null"`
}

이제 서버를 시작하기 위한 기능을 작성하면 됩니다.

// internal/models/database.go

type Database struct {
    Client *gorm.DB
}

Serve 기능은 지정된 포트에서 서버를 시작하고 프로세스 중에 오류가 있으면 오류를 반환합니다.

2d단계: 구현 결합 및 애플리케이션 실행

main.go 파일에서 구현을 가져와서 구현을 결합하고 앱을 실행하세요.

// internal/models/database.go

func NewDatabase() (*Database, error) {

    // Construct a connection string using environment variables for database configuration.
    configurations := fmt.Sprintf("host=%v port=%v user=%v password=%v dbname=%v sslmode=%v",
        os.Getenv("DB_HOST"), os.Getenv("DB_PORT"), os.Getenv("DB_USERNAME"),
        os.Getenv("DB_PASSWORD"), os.Getenv("DB_NAME"), os.Getenv("SSL_MODE"))

    // Open a connection to the database using GORM and PostgreSQL driver.
    db, err := gorm.Open(postgres.New(postgres.Config{
        DSN:                  configurations,
        PreferSimpleProtocol: true,
    }), &gorm.Config{NamingStrategy: schema.NamingStrategy{
        SingularTable: true,
    }})
    if err != nil {
        return nil, err
    }

    // Enable connection pooling by configuring maximum idle and open connections.
    sqlDB, err := db.DB()
    if err != nil {
        return nil, err
    }
    sqlDB.SetMaxIdleConns(10)
    sqlDB.SetMaxOpenConns(100)

    // Return the Database instance with the established database connection.
    return &Database{
        Client: db,
    }, nil
}

main.go 파일에서 앱 시작을 인스턴스화하는 Run 함수를 선언한 다음 메인 함수에서 해당 함수를 호출할 수 있습니다.

// internal/models/migrations.go

func (d *Database) MigrateDB() error {
    log.Println("Database Migration in Process...")

    // Use GORM AutoMigrate to migrate all the database schemas.
    err := d.Client.AutoMigrate(&User{})
    if err != nil {
        return err
    }

    log.Println("Database Migration Complete!")
    return nil
}

Run 함수는 데이터베이스 인스턴스를 생성하고, 마이그레이션 기능을 초기화하고, HTTP 및 사용자 구현을 초기화하고, 서버를 시작합니다.

메인 함수에서 Run 함수를 호출하여 애플리케이션을 시작할 수 있습니다.

// internal/models/users.go

func (d *Database) CreateUser(ctx context.Context, user *users.User) error {
    newUser := &User{
        Username: user.Username,
        Email:    user.Email,
        IsActive: false,
    }

    if err := d.Client.WithContext(ctx).Create(newUser).Error; err != nil {
        return err
    }

    return nil
}

// GetUserByID returns the user with a specified id
func (d *Database) GetUserByID(ctx context.Context, id int64) (users.User, error) {
    user := users.User{}
    if err := d.Client.WithContext(ctx).Where("id = ?", id).First(&user).Error; err != nil {
        return users.User(User{}), err
    }
    return users.User(User{
        Username: user.Username,
        Email:    user.Email,
        IsActive: user.IsActive,
    }), nil
}

// UpdateUser updates an existing user in the database
func (d *Database) UpdateUser(ctx context.Context, updatedUser users.User, id uint) error {
    // Check if the user with the specified ID exists
    var existingUser User
    if err := d.Client.WithContext(ctx).Where("id = ?", id).First(&existingUser).Error; err != nil {
        return err
    }

    // Update the fields of the existing user with the new values
    existingUser.Username = updatedUser.Username
    existingUser.Email = updatedUser.Email
    existingUser.IsActive = updatedUser.IsActive

    // Save the updated user back to the database
    if err := d.Client.WithContext(ctx).Save(&existingUser).Error; err != nil {
        return err
    }

    return nil
}

// DeleteUser deletes a user from the database by their ID

func (d *Database) DeleteUser(ctx context.Context, id uint) error {
    // Check if the user with the specified ID exists
    var existingUser User
    if err := d.Client.WithContext(ctx).Where("id = ?", id).First(&existingUser).Error; err != nil {
        return err
    }

    // Delete the user from the database
    if err := d.Client.WithContext(ctx).Delete(&existingUser).Error; err != nil {
        return err
    }

    return nil
}

Docker를 사용한 컨테이너화를 고려하기 전에 애플리케이션이 제대로 실행되어야 합니다.

3단계: Dockerfile 작성

이제 프로그램을 성공적으로 구축하고 실행했으므로 Docker를 사용하여 컨테이너화를 진행할 수 있습니다.

Dockerfile은 빌드와 최종 단계라는 두 단계로 구성됩니다. 이 접근 방식은 이미지 크기를 줄이고, 공격 표면을 줄여 보안 위험을 최소화하며, 효율적인 런타임 성능을 보장하고, 다양한 개발 및 배포 단계에서 재현성을 촉진합니다.

또한 Alpine Linux를 Docker 이미지의 기본 이미지로 사용하게 됩니다. 미니멀한 디자인으로 더 효율적이고 안전하기 때문에 이미지 크기가 더 작고, 빌드가 더 빠르며, 공격 표면이 줄어들기 때문입니다.

3a단계: 빌드 단계

Dockerfile의 빌드 및 최종 단계를 사용하면 Docker 이미지를 효율적으로 생성할 수 있습니다. 빌드 단계는 빌드 도구와 종속성이 포함된 기본 이미지로 시작하여 애플리케이션 아티팩트를 컴파일하고 잠재적으로 큰 중간 이미지를 생성합니다.

빌드 단계의 Dockerfile 내용은 다음과 같습니다.

go mod init

1. FROM golang:1.20-alpine AS build: 이 줄은 빌드 단계의 기본 이미지를 지정합니다. 버전 1.20으로 태그된 공식 Golang Docker 이미지로 시작하며 Alpine Linux를 기반으로 합니다. AS 빌드 부분에서는 이 단계에 나중에 참조할 수 있도록 "빌드"라는 이름을 지정합니다.
2. WORKDIR /app: 이 줄은 컨테이너 내부의 작업 디렉터리를 /app으로 설정합니다. Docker는 이 디렉터리에서 후속 명령을 실행합니다.
3. 복사 . .: 이 명령은 현재 디렉터리의 내용(아마도 Go 애플리케이션 소스 코드 및 기타 필요한 파일)을 컨테이너 내부의 /app 디렉터리에 복사합니다.
4. RUN go build -o server ./cmd/server: Go 애플리케이션을 빌드하는 명령입니다. go build 명령을 사용하여 현재 디렉터리의 Go 코드를 컴파일하고 바이너리를 server로 출력합니다. ./cmd/server 인수는 /app 디렉터리를 기준으로 하는 애플리케이션 코드의 위치입니다.

3b단계: 최종 단계

마지막 단계에서는 더 작은 기본 이미지를 사용하고 필요한 런타임 구성 요소만 복사하여 제작에 최적화된 컴팩트한 이미지를 만듭니다.

최종 단계에 대한 Dockerfile의 내용은 다음과 같습니다.

go mod init

1. FROM alpine:latest: 마지막 단계에서는 Alpine Linux 기본 이미지로 시작할 수 있습니다. latest 태그는 사용 가능한 최신 Alpine Linux 버전을 지정합니다.
2. WORKDIR /app: 이 줄은 컨테이너 내부의 작업 디렉터리를 /app으로 설정합니다. Docker는 이 디렉터리에서 후속 명령을 실행합니다.
3. COPY --from=build /app/server .: 이 명령은 이전 "빌드 단계"에서 server라는 바이너리 파일을 /app 디렉터리로 복사합니다. 최종 컨테이너 내부. 이 바이너리는 빌드 단계에서 빌드한 컴파일된 Go 애플리케이션입니다.
4. EXPOSE 8080: 여기서는 애플리케이션이 포트 8080을 수신하도록 지정합니다. 이는 선언이며 실제로 포트를 열지는 않습니다. 이는 애플리케이션에서 사용할 포트를 문서화하는 방법입니다.
5. CMD ["./server"]: 이 명령은 이미지를 기반으로 컨테이너를 실행할 때 실행됩니다. Go 애플리케이션인 server 바이너리를 실행하도록 지정합니다. 이 명령은 컨테이너 내부에서 애플리케이션을 시작합니다.

4단계: Docker 이미지 빌드 및 실행

Dockerfile을 작성한 후 파일 빌드 및 실행을 진행할 수 있습니다.
build 명령으로 파일에서 Docker 이미지를 빌드하려면 이 명령을 실행하세요.

go get github.com/gorilla/mux

go get gorm.io/gorm
go get gorm.io/driver/postgres

-t 플래그는 Docker 이미지에 대한 태그를 betterapp으로 지정하고 다음 점(.)은 현재 디렉터리에 Dockerfile을 빌드하려는 것을 지정합니다.

run 명령을 사용하여 이미지를 실행하고 -p 플래그를 사용하여 컨테이너에서 호스트 시스템으로의 포트 매핑을 지정할 수 있습니다.

.
├── Dockerfile
├── cmd
│   └── server
│       └── main.go
└── internal
    ├── http
    │   ├── handlers.go
    │   └── users.go
    ├── models
    │   ├── database.go
    │   ├── migrations.go
    │   └── users.go
    └── users
        └── user.go

6 directories, 11 files

다음 -e 플래그는 애플리케이션에 대한 환경 변수를 지정하기 위한 것입니다.

5단계: Docker를 사용하여 Go 애플리케이션 배포

Docker Compose는 여러 Docker 컨테이너 작업을 단순화하는 컨테이너 오케스트레이션 도구입니다. Docker Compose를 사용하여 Go 앱과 해당 구성 요소를 조정할 수 있습니다.

YAML 파일을 사용하여 명령을 지정하면 Docker Compose가 애플리케이션을 설정하여 시간과 복잡성을 줄여줍니다.

먼저 아래 명령을 사용하여 Docker Compose YAML 파일을 생성하고 편집기에서 파일을 엽니다.

package models

import (
    // imports from the user implementation
    "BetterApp/internal/users"

    "context"
    "gorm.io/gorm"
    "fmt"
    "gorm.io/driver/postgres"
    "gorm.io/gorm/schema"
    "os"
)

Dockerfile을 생성한 후 앱 배포를 위한 명령과 지시어 작성을 시작할 수 있습니다.

// internal/models/users.go

type User struct {
    gorm.Model
    Username string `gorm:"unique;not null"`
    Email    string `gorm:"unique;not null"`
    IsActive bool   `gorm:"not null"`
}

YAML 파일은 두 가지 서비스, 즉 데이터베이스 컨테이너 인스턴스인 my-postgres와 환경 변수, 포트 및 종속성을 구성하기 전의 Go 애플리케이션인 웹 서비스를 정의합니다.

이제 docker-compose 빌드 명령을 사용하여 이미지 빌드를 진행할 수 있습니다.

// internal/models/database.go

type Database struct {
    Client *gorm.DB
}

출력은 다음과 유사해야 합니다.

마지막으로 docker-compose up 명령을 사용하여 컨테이너를 실행할 수 있습니다.

go mod init

-d 플래그는 터미널 세션에 관계없이 컨테이너를 분리 모드로 실행합니다.

명령 실행 결과는 다음과 같습니다.

터미널을 닫아도 컨테이너는 계속 실행됩니다.

컨테이너가 작동되면 CURL 요청을 실행하여 API를 테스트할 수 있습니다.

go get github.com/gorilla/mux

go get gorm.io/gorm
go get gorm.io/driver/postgres

축하합니다. Docker 및 Docker Compose를 사용하여 작동하는 Go 앱을 성공적으로 배포하고 실행했습니다.

결론

Docker 및 Docker Compose를 사용하여 Go 앱 배포를 구축하고 단순화하는 방법을 배웠습니다. 개발 여정을 계속하면서 여기에서 얻은 기술과 이해는 원활한 배포와 운영 우수성을 보장하는 데 필수적인 자산이 될 것입니다.

Dockerfile 빌드 최적화 또는 대규모 애플리케이션을 위한 Docker Swarm 구현과 같은 고급 Docker 기능을 살펴보세요.

위 내용은 Docker를 사용하여 Go 애플리케이션을 배포하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!