Ver3.0 ๐ณ Go์ธ์ด Docker ์ปจํ ์ด๋ํ์ ๋ฉํฐ์คํ ์ด์ง ๋น๋๋ก ์ด๊ฒฝ๋ ์ด๋ฏธ์ง ๋ง๋ค๊ธฐ

๐ณ Go์ธ์ด Docker ์ปจํ ์ด๋ํ์ ๋ฉํฐ์คํ ์ด์ง ๋น๋๋ก ์ด๊ฒฝ๋ ์ด๋ฏธ์ง ๋ง๋ค๊ธฐ
์น๊ตฌ์ผ, ์ค๋์ Go ์ ํ๋ฆฌ์ผ์ด์ ์ Docker๋ก ํฌ์ฅํ๋ ๋ง๋ฒ์ ์๋ ค์ค๊ฒ! ๐
๐ฏ ์ Go์ Docker๋ ์ฐฐ๋ก๊ถํฉ์ผ๊น?
์ผ, ์์งํ ๋งํด์ Go ์ธ์ด๋ก ๊ฐ๋ฐํ๋ฉด์ Docker ์ ์ฐ๋ฉด ์ง์ง ์๊น๋ค๋ ๊ฑฐ ์์? ๐ Go๋ ์ ์ ์ปดํ์ผ ์ธ์ด๋ผ์ ์คํ ํ์ผ ํ๋๋ง ์์ผ๋ฉด ๋์๊ฐ๊ฑฐ๋ . ์ด๊ฒ ๋ฌด์จ ๋ป์ด๋๋ฉด, ๋ณต์กํ ๋ฐํ์ ํ๊ฒฝ์ด๋ ์์กด์ฑ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ฐ๋ก ์ค์นํ ํ์๊ฐ ์๋ค๋ ๊ฑฐ์ง!
์๋ฅผ ๋ค์ด๋ณผ๊ฒ. Python์ด๋ Node.js๋ก ๊ฐ๋ฐํ๋ฉด ํด๋น ๋ฐํ์์ด ์๋ฒ์ ๊น๋ ค์์ด์ผ ํ์์? ๊ทผ๋ฐ Go๋ ์ปดํ์ผํ๋ฉด ๊ทธ๋ฅ ์คํ ํ์ผ ํ๋๊ฐ ๋! ๋์. ์ด ํ์ผ๋ง ์์ผ๋ฉด ์ด๋์๋ ์คํ ๊ฐ๋ฅํด. ์ด๋ฐ ํน์ฑ ๋๋ถ์ Docker ์ด๋ฏธ์ง๋ฅผ ๋ง๋ค ๋ ์์ฒญ๋๊ฒ ์๊ฒ ๋ง๋ค ์ ์์ด. ๐
์ด๋ฐ ๊ฒฝ๋ํ๊ฐ ์ ์ค์ํ๋๊ณ ? ๐ค ์ด๋ฏธ์ง ํฌ๊ธฐ๊ฐ ์์ผ๋ฉด ๋ฐฐํฌ ์๋๊ฐ ๋นจ๋ผ์ง๊ณ , ๋คํธ์ํฌ ๋์ญํญ์ ์ ๊ฒ ์ฐ๊ณ , ์คํ ๋ฆฌ์ง ๋น์ฉ๋ ์ ์ฝ๋๊ฑฐ๋ . ํนํ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ ์ฒ์์ ์์ญ ๊ฐ์ ์๋น์ค๋ฅผ ์ด์ํ๋ค๋ฉด ์ด ์ฐจ์ด๊ฐ ์์ฒญ๋๊ฒ ์ปค์ ธ!
๐๏ธ ๊ธฐ๋ณธ์ ์ธ Go ์ ํ๋ฆฌ์ผ์ด์ Dockerํํ๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํด๋ณผ๊น? ๋จผ์ ๊ฐ๋จํ Go ์น ์๋ฒ๋ฅผ ๋ง๋ค์ด๋ณด์. ์ด๊ฑด ์ ๋ง ๊ธฐ์ด์ ์ธ ์์ ์ธ๋ฐ, ์ค์ ์์๋ ์ด ํจํด์ ๊ทธ๋๋ก ์ฌ์ฉํ ์ ์์ด.
๐ ์ํ Go ์ ํ๋ฆฌ์ผ์ด์ ์์ฑ
๋จผ์ main.go ํ์ผ์ ๋ง๋ค์ด๋ณด์:
package main
import (
"fmt"
"log"
"net/http"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "์๋
! Go + Docker ์กฐํฉ ์ต๊ณ ์ผ! ๐")
})
http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, "OK")
})
log.Println("์๋ฒ ์์: ํฌํธ 8080")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}
์ด ์ฝ๋๋ 8080 ํฌํธ์์ ๊ฐ๋จํ ์น ์๋ฒ๋ฅผ ์คํํ๋ ๊ฑฐ์ผ. / ๊ฒฝ๋ก๋ก ์ ์ํ๋ฉด ์ธ์ฌ๋ง์ ๋ณด์ฌ์ฃผ๊ณ , /health ๊ฒฝ๋ก๋ ํฌ์ค์ฒดํฌ์ฉ์ด์ง. ์ค์ ํ๋ก๋์
ํ๊ฒฝ์์๋ ํฌ์ค์ฒดํฌ ์๋ํฌ์ธํธ๊ฐ ์ ๋ง ์ค์ํด! ๐ฅ
๐ ๊ธฐ๋ณธ Dockerfile ์์ฑ (๋น์ถ์ฒ ๋ฐฉ์)
์ฒ์ Docker๋ฅผ ์ ํ๋ฉด ๋ณดํต ์ด๋ ๊ฒ ์์ฑํ๊ฒ ๋ผ:
FROM golang:1.21 WORKDIR /app COPY . . RUN go build -o main . EXPOSE 8080 CMD ["./main"]
์ด๋ฏธ์ง๋ฅผ ๋น๋ํ๊ณ ํ์ธํด๋ณด๋ฉด:
docker build -t myapp:basic . docker images myapp:basic # ๊ฒฐ๊ณผ REPOSITORY TAG IMAGE ID CREATED SIZE myapp basic abc123def456 2 minutes ago 862MB
๋ดค์ง? 862MB๋ ๋์. ์ด๊ฑด ๋๋ฌด ํฌ์์! ๐ฑ
๐ญ ๋ฉํฐ์คํ ์ด์ง ๋น๋์ ๋ง๋ฒ
์, ์ด์ ์ง์ง ํต์ฌ ๊ธฐ์ ์ ์๋ ค์ค๊ฒ! ๋ฉํฐ์คํ ์ด์ง ๋น๋๋ Docker์ ๊ฟ๊ธฐ๋ฅ ์ค ํ๋์ผ. ์ด๋ฆ์์ ์ ์ ์๋ฏ์ด ์ฌ๋ฌ ๋จ๊ณ(stage)๋ก ๋๋ ์ ๋น๋ํ๋ ๊ฑฐ์ง. ๐ช
๊ฐ๋ ์ ๊ฐ๋จํด. ์ฒซ ๋ฒ์งธ ์คํ ์ด์ง์์๋ Go ์ปดํ์ผ๋ฌ๊ฐ ์๋ ํฐ ์ด๋ฏธ์ง๋ก ์ ํ๋ฆฌ์ผ์ด์ ์ ๋น๋ํ๊ณ , ๋ ๋ฒ์งธ ์คํ ์ด์ง์์๋ ์์ ๋ฒ ์ด์ค ์ด๋ฏธ์ง์ ์ปดํ์ผ๋ ๋ฐ์ด๋๋ฆฌ๋ง ๋ณต์ฌํ๋ ๊ฑฐ์ผ. ๋น๋ ๋๊ตฌ๋ค์ ์ต์ข ์ด๋ฏธ์ง์ ํฌํจ๋์ง ์์!
๐ฅ ์ต์ ํ๋ Dockerfile ์์ฑ
# ๋น๋ ์คํ ์ด์ง FROM golang:1.21-alpine AS builder # ํ์ํ ๋น๋ ๋๊ตฌ ์ค์น RUN apk add --no-cache git WORKDIR /app # ์์กด์ฑ ํ์ผ ๋จผ์ ๋ณต์ฌ (์บ์ฑ ์ต์ ํ) COPY go.mod go.sum ./ RUN go mod download # ์์ค ์ฝ๋ ๋ณต์ฌ COPY . . # ์ ์ ๋งํฌ ๋ฐ์ด๋๋ฆฌ ๋น๋ RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o main . # ์คํ ์คํ ์ด์ง FROM alpine:latest # ๋ณด์ ์ ๋ฐ์ดํธ ๋ฐ CA ์ธ์ฆ์ ์ค์น RUN apk --no-cache add ca-certificates tzdata WORKDIR /root/ # ๋น๋ ์คํ ์ด์ง์์ ๋ฐ์ด๋๋ฆฌ๋ง ๋ณต์ฌ COPY --from=builder /app/main . EXPOSE 8080 CMD ["./main"]
์, ์ฝ๋๊ฐ ์ข ๊ธธ์ด ๋ณด์ด์ง? ํ๋์ฉ ๋ฏ์ด๋ณด์! ๐
-
golang:1.21-alpine์ ์ฌ์ฉํด์ ๊ธฐ๋ณธ golang ์ด๋ฏธ์ง๋ณด๋ค ์๊ฒ ์์-
go.mod์ go.sum์ ๋จผ์ ๋ณต์ฌํด์ ์์กด์ฑ ๋ค์ด๋ก๋๋ฅผ ์บ์ฑ-
CGO_ENABLED=0์ผ๋ก ์์ Go ๋ฐ์ด๋๋ฆฌ ์์ฑ (C ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์กด์ฑ ์ ๊ฑฐ)2. ์คํ ์คํ ์ด์ง:
-
alpine:latest ์ฌ์ฉ (์ฝ 5MB ํฌ๊ธฐ!)- CA ์ธ์ฆ์ ์ค์น (HTTPS ํต์ ํ ๋ ํ์)
- ๋น๋์์ ์ปดํ์ผ๋ ๋ฐ์ด๋๋ฆฌ๋ง ๋ณต์ฌ
์ด์ ๋น๋ํด๋ณด์:
docker build -t myapp:optimized . docker images myapp:optimized # ๊ฒฐ๊ณผ REPOSITORY TAG IMAGE ID CREATED SIZE myapp optimized xyz789abc123 10 seconds ago 12MB
์ง์! ๐ 862MB์์ 12MB๋ก ์ค์์ด! ์ฝ 98.6% ๊ฐ์์ผ. ์ด ์ ๋๋ฉด ๋ฐฐํฌํ ๋ ๋คํธ์ํฌ ์ ์ก ์๊ฐ์ด ์์ฒญ ์ค์ด๋ค๊ฒ ์ง?
๐ ๋ ๊ทน๋จ์ ์ธ ์ต์ ํ: Scratch ์ด๋ฏธ์ง
์น๊ตฌ์ผ, ๋ ์๊ฒ ๋ง๋ค ์ ์์๊น? ์์ด! scratch๋ผ๋ ํน๋ณํ ๋ฒ ์ด์ค ์ด๋ฏธ์ง๋ฅผ ์ฌ์ฉํ๋ฉด ๋ผ. ์ด๊ฑด ๋ง ๊ทธ๋๋ก ๋น ์ด๋ฏธ์ง์ผ. ์๋ฌด๊ฒ๋ ์์ด! ๐ฎ
# ๋น๋ ์คํ ์ด์ง FROM golang:1.21-alpine AS builder WORKDIR /app COPY go.mod go.sum ./ RUN go mod download COPY . . # ์์ ์ ์ ๋งํฌ ๋ฐ์ด๋๋ฆฌ ๋น๋ RUN CGO_ENABLED=0 GOOS=linux go build -a -ldflags '-w -s -extldflags "-static"' -o main . # ์คํ ์คํ ์ด์ง - scratch ์ฌ์ฉ! FROM scratch # CA ์ธ์ฆ์ ๋ณต์ฌ (HTTPS ํต์ ์ฉ) COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ # ํ์์กด ๋ฐ์ดํฐ ๋ณต์ฌ (ํ์์) COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo # ๋ฐ์ด๋๋ฆฌ ๋ณต์ฌ COPY --from=builder /app/main /main EXPOSE 8080 ENTRYPOINT ["/main"]
์ด๋ ๊ฒ ํ๋ฉด:
docker build -t myapp:scratch . docker images myapp:scratch # ๊ฒฐ๊ณผ REPOSITORY TAG IMAGE ID CREATED SIZE myapp scratch def456ghi789 5 seconds ago 6.8MB
6.8MB! ๐คฏ ์ด์ ์ง์ง ์ต์ํ์ ํฌ๊ธฐ์ผ. ํ์ง๋ง ์ฃผ์ํ ์ ์ด ์์ด!
2. CA ์ธ์ฆ์ ํ์: HTTPS ํต์ ํ๋ ค๋ฉด ์ธ์ฆ์๋ฅผ ์ง์ ๋ณต์ฌํด์ผ ํด
3. ํ์์กด ์ค์ : ์๊ฐ ๊ด๋ จ ๊ธฐ๋ฅ ์ฐ๋ ค๋ฉด ํ์์กด ๋ฐ์ดํฐ๋ ๋ณต์ฌ ํ์
4. CGO ์ฌ์ฉ ๋ถ๊ฐ: C ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์์กดํ๋ ํจํค์ง๋ ๋ชป ์จ
๊ฐ์ธ์ ์ผ๋ก๋ ํ๋ก๋์ ํ๊ฒฝ์์๋ alpine ๋ฒ ์ด์ค๋ฅผ ์ถ์ฒํด. ํฌ๊ธฐ๋ ์กฐ๊ธ ๋ ํฌ์ง๋ง ๋๋ฒ๊น ํ ๋ ํจ์ฌ ํธํ๊ฑฐ๋ ! ๐
โก ๋น๋ ์๋ ์ต์ ํ ์ ๋ต
์ด๋ฏธ์ง ํฌ๊ธฐ๋ ์ค์ํ์ง๋ง, ๋น๋ ์๋๋ ์์ฒญ ์ค์ํด! ํนํ CI/CD ํ์ดํ๋ผ์ธ์์ ๋งค๋ฒ ๋น๋ํ ๋๋ง๋ค ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ฉด ๊ฐ๋ฐ ์๋๊ฐ ๋๋ ค์ง์์? ๐
๐ฆ ๋ ์ด์ด ์บ์ฑ ํ์ฉํ๊ธฐ
Docker๋ ๋ ์ด์ด ์บ์ฑ์ด๋ผ๋ ๋ฉ์ง ๊ธฐ๋ฅ์ด ์์ด. ๊ฐ ๋ช ๋ น์ด(RUN, COPY ๋ฑ)๊ฐ ๋ ์ด์ด๋ฅผ ๋ง๋๋๋ฐ, ๋ณ๊ฒฝ๋์ง ์์ ๋ ์ด์ด๋ ์บ์์์ ์ฌ์ฌ์ฉํด. ์ด๊ฑธ ์ ํ์ฉํ๋ฉด ๋น๋ ์๋๋ฅผ ์์ฒญ ๋์ผ ์ ์์ด!
# โ ๋นํจ์จ์ ์ธ ๋ฐฉ์ FROM golang:1.21-alpine AS builder WORKDIR /app COPY . . # ๋ชจ๋ ํ์ผ ๋ณต์ฌ RUN go mod download # ์์ค ์ฝ๋ ๋ฐ๋ ๋๋ง๋ค ์์กด์ฑ ๋ค์ ๋ค์ด๋ก๋! RUN go build -o main . # โ ํจ์จ์ ์ธ ๋ฐฉ์ FROM golang:1.21-alpine AS builder WORKDIR /app COPY go.mod go.sum ./ # ์์กด์ฑ ํ์ผ๋ง ๋จผ์ ๋ณต์ฌ RUN go mod download # ์์กด์ฑ ์บ์ฑ! COPY . . # ๊ทธ ๋ค์ ์์ค ์ฝ๋ ๋ณต์ฌ RUN go build -o main .
์ฐจ์ด๊ฐ ๋ณด์ด์ง? ๋ ๋ฒ์งธ ๋ฐฉ์์ go.mod๋ go.sum์ด ๋ณ๊ฒฝ๋์ง ์์ผ๋ฉด go mod download ๋จ๊ณ๋ฅผ ๊ฑด๋๋ฐ์ด! ์ค์ ๋ก ํ
์คํธํด๋ณด๋ฉด:
์์ค ์ฝ๋๋ง ์์ ํ ์ฌ๋น๋ (๋นํจ์จ์ ๋ฐฉ์): ์ฝ 2๋ถ 20์ด
์์ค ์ฝ๋๋ง ์์ ํ ์ฌ๋น๋ (ํจ์จ์ ๋ฐฉ์): ์ฝ 15์ด!
์์กด์ฑ ๋ค์ด๋ก๋๋ฅผ ๊ฑด๋๋ฐ๋๊น 10๋ฐฐ ๊ฐ๊น์ด ๋นจ๋ผ์ก์ด! ๐
๐ฏ .dockerignore ํ์ผ ํ์ฉ
Git์ .gitignore๊ฐ ์๋ฏ์ด, Docker์๋ .dockerignore๊ฐ ์์ด. ์ด๊ฑธ ์ฌ์ฉํ๋ฉด ๋ถํ์ํ ํ์ผ๋ค์ ๋น๋ ์ปจํ
์คํธ์์ ์ ์ธํ ์ ์์ด.
# .dockerignore ์์ .git .gitignore README.md .env .env.* docker-compose.yml Dockerfile .dockerignore *.md .vscode .idea *.log tmp/ vendor/ node_modules/ coverage/ *.test *.out
์ด๋ ๊ฒ ํ๋ฉด ๋น๋ ์ปจํ ์คํธ๊ฐ ์์์ ธ์ Docker ๋ฐ๋ชฌ์ผ๋ก ํ์ผ์ ์ ์กํ๋ ์๊ฐ์ด ์ค์ด๋ค์ด. ํนํ ํ๋ก์ ํธ๊ฐ ํฌ๋ฉด ํด์๋ก ํจ๊ณผ๊ฐ ์ปค์ ธ! ๐ฆ
๐ง ๋น๋ ์ธ์(Build Args) ํ์ฉ
ํ๊ฒฝ์ ๋ฐ๋ผ ๋ค๋ฅธ ์ค์ ์ผ๋ก ๋น๋ํ๊ณ ์ถ์ ๋๊ฐ ์์์? ๊ทธ๋ด ๋ ๋น๋ ์ธ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ผ:
FROM golang:1.21-alpine AS builder
# ๋น๋ ์ธ์ ์ ์
ARG VERSION=dev
ARG BUILD_TIME
ARG GIT_COMMIT
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
# ๋น๋ ์ ๋ฒ์ ์ ๋ณด ์ฃผ์
RUN CGO_ENABLED=0 go build \
-ldflags "-X main.Version=${VERSION} -X main.BuildTime=${BUILD_TIME} -X main.GitCommit=${GIT_COMMIT}" \
-o main .
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
EXPOSE 8080
CMD ["./main"]
๊ทธ๋ฆฌ๊ณ Go ์ฝ๋์์:
package main
import (
"fmt"
"log"
"net/http"
)
var (
Version = "unknown"
BuildTime = "unknown"
GitCommit = "unknown"
)
func main() {
http.HandleFunc("/version", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Version: %s\nBuild Time: %s\nGit Commit: %s\n",
Version, BuildTime, GitCommit)
})
log.Printf("Starting server v%s (commit: %s)", Version, GitCommit)
http.ListenAndServe(":8080", nil)
}
๋น๋ํ ๋:
docker build \ --build-arg VERSION=1.2.3 \ --build-arg BUILD_TIME=$(date -u +"%Y-%m-%dT%H:%M:%SZ") \ --build-arg GIT_COMMIT=$(git rev-parse --short HEAD) \ -t myapp:1.2.3 .
์ด์ /version ์๋ํฌ์ธํธ๋ก ์ ์ํ๋ฉด ๋น๋ ์ ๋ณด๋ฅผ ํ์ธํ ์ ์์ด! ์ด์ ํ๊ฒฝ์์ ์ด๋ค ๋ฒ์ ์ด ๋ฐฐํฌ๋์ด ์๋์ง ํ์ธํ ๋ ์ ๋ง ์ ์ฉํด. ๐ท๏ธ
๐ก๏ธ ๋ณด์ ๊ฐํ ์ ๋ต
๊ฒฝ๋ํ๋ ์ค์ํ์ง๋ง ๋ณด์๋ ์ ๋ ๋์น๋ฉด ์ ๋ผ! Docker ์ปจํ ์ด๋๋ ๊ฒฉ๋ฆฌ๋์ด ์๋ค๊ณ ํด๋ ์ ๋๋ก ์ค์ ํ์ง ์์ผ๋ฉด ๋ณด์ ์ทจ์ฝ์ ์ด ์๊ธธ ์ ์์ด. ๐จ
๐ค Non-root ์ฌ์ฉ์๋ก ์คํํ๊ธฐ
๊ธฐ๋ณธ์ ์ผ๋ก Docker ์ปจํ ์ด๋๋ root ๊ถํ์ผ๋ก ์คํ๋ผ. ์ด๊ฑด ๋ณด์์ ์ข์ง ์์. ๋ง์ฝ ์ปจํ ์ด๋๊ฐ ํดํน๋นํ๋ฉด ๊ณต๊ฒฉ์๊ฐ root ๊ถํ์ ๊ฐ์ง๊ฒ ๋๊ฑฐ๋ !
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o main .
FROM alpine:latest
# ๋ณด์ ์
๋ฐ์ดํธ
RUN apk --no-cache add ca-certificates && \
apk upgrade
# ์ผ๋ฐ ์ฌ์ฉ์ ์์ฑ
RUN addgroup -g 1000 appgroup && \
adduser -D -u 1000 -G appgroup appuser
WORKDIR /home/appuser
# ๋ฐ์ด๋๋ฆฌ ๋ณต์ฌ ๋ฐ ๊ถํ ์ค์
COPY --from=builder /app/main .
RUN chown appuser:appgroup main
# ์ผ๋ฐ ์ฌ์ฉ์๋ก ์ ํ
USER appuser
EXPOSE 8080
CMD ["./main"]
์ด์ ์ปจํ ์ด๋๊ฐ ์ผ๋ฐ ์ฌ์ฉ์ ๊ถํ์ผ๋ก ์คํ๋ผ! ํจ์ฌ ์์ ํ์ง? ๐
๐ ์ทจ์ฝ์ ์ค์บํ๊ธฐ
์ด๋ฏธ์ง๋ฅผ ๋น๋ํ ํ์๋ ์ทจ์ฝ์ ์ค์บ์ ํด์ผ ํด. Docker Desktop์ ๋ด์ฅ๋ ์ค์บ ๊ธฐ๋ฅ์ด๋ Trivy ๊ฐ์ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ ์ ์์ด:
# Docker ๋ด์ฅ ์ค์บ docker scan myapp:optimized # Trivy ์ฌ์ฉ (๋ ์์ธํจ) docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \ aquasec/trivy image myapp:optimized
์ทจ์ฝ์ ์ด ๋ฐ๊ฒฌ๋๋ฉด ๋ฒ ์ด์ค ์ด๋ฏธ์ง๋ฅผ ์ ๋ฐ์ดํธํ๊ฑฐ๋ ํจํค์ง๋ฅผ ์ ๊ทธ๋ ์ด๋ํด์ผ ํด. ์ ๊ธฐ์ ์ผ๋ก ์ค์บํ๋ ๊ฒ ์ค์ํด! ๐
๐ซ ๋ฏผ๊ฐ ์ ๋ณด ๊ด๋ฆฌ
์ ๋๋ก, ์ ๋๋ก ์ด๋ฏธ์ง์ ๋น๋ฐ๋ฒํธ๋ API ํค ๊ฐ์ ๋ฏผ๊ฐ ์ ๋ณด๋ฅผ ๋ฃ์ผ๋ฉด ์ ๋ผ! ๋์ ํ๊ฒฝ ๋ณ์๋ Docker Secrets๋ฅผ ์ฌ์ฉํด:
package main
import (
"log"
"os"
)
func main() {
// โ ํ๋์ฝ๋ฉ ๊ธ์ง!
// apiKey := "sk-1234567890abcdef"
// โ
ํ๊ฒฝ ๋ณ์ ์ฌ์ฉ
apiKey := os.Getenv("API_KEY")
if apiKey == "" {
log.Fatal("API_KEY environment variable is required")
}
dbPassword := os.Getenv("DB_PASSWORD")
if dbPassword == "" {
log.Fatal("DB_PASSWORD environment variable is required")
}
// ์ ํ๋ฆฌ์ผ์ด์
๋ก์ง...
}
์คํํ ๋:
docker run -e API_KEY=your-key -e DB_PASSWORD=your-password myapp:optimized # ๋๋ .env ํ์ผ ์ฌ์ฉ docker run --env-file .env myapp:optimized
ํ๋ก๋์ ํ๊ฒฝ์์๋ Kubernetes Secrets, AWS Secrets Manager, HashiCorp Vault ๊ฐ์ ์ ๋ฌธ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ ์ข์! ๐
๐จ ์ค์ ์์ : REST API ์๋ฒ
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋ ์ด์ ์ค์ ์์ ๋ฅผ ๋ง๋ค์ด๋ณด์! ๊ฐ๋จํ TODO REST API ์๋ฒ๋ฅผ ๋ง๋ค๊ณ Docker๋ก ์ปจํ ์ด๋ํํด๋ณผ๊ฒ. ๐
๐ ํ๋ก์ ํธ ๊ตฌ์กฐ
todo-api/ โโโ main.go โโโ go.mod โโโ go.sum โโโ Dockerfile โโโ .dockerignore โโโ handlers/ โ โโโ todo.go โโโ models/ โ โโโ todo.go โโโ README.md
๐ป ์ฝ๋ ์์ฑ
๋จผ์ models/todo.go:
package models
import "time"
type Todo struct {
ID string `json:"id"`
Title string `json:"title"`
Completed bool `json:"completed"`
CreatedAt time.Time `json:"created_at"`
}
var todos = make(map[string]*Todo)
๋ค์ handlers/todo.go:
package handlers
import (
"encoding/json"
"net/http"
"time"
"github.com/google/uuid"
"todo-api/models"
)
func GetTodos(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
todoList := make([]*models.Todo, 0)
for _, todo := range models.todos {
todoList = append(todoList, todo)
}
json.NewEncoder(w).Encode(todoList)
}
func CreateTodo(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var todo models.Todo
if err := json.NewDecoder(r.Body).Decode(&todo); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
todo.ID = uuid.New().String()
todo.CreatedAt = time.Now()
models.todos[todo.ID] = &todo
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(todo)
}
๋ฉ์ธ ํ์ผ main.go:
package main
import (
"log"
"net/http"
"os"
"todo-api/handlers"
)
var (
Version = "dev"
BuildTime = "unknown"
)
func main() {
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Write([]byte("OK"))
})
http.HandleFunc("/version", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{"version":"` + Version + `","build_time":"` + BuildTime + `"}`))
})
http.HandleFunc("/todos", func(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
handlers.GetTodos(w, r)
case http.MethodPost:
handlers.CreateTodo(w, r)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
})
log.Printf("๐ TODO API Server v%s starting on port %s", Version, port)
if err := http.ListenAndServe(":"+port, nil); err != nil {
log.Fatal(err)
}
}
๐ณ ์ต์ ํ๋ Dockerfile
# ๋น๋ ์คํ
์ด์ง
FROM golang:1.21-alpine AS builder
# ๋น๋ ๋๊ตฌ ์ค์น
RUN apk add --no-cache git ca-certificates tzdata
WORKDIR /app
# ์์กด์ฑ ์บ์ฑ
COPY go.mod go.sum ./
RUN go mod download && go mod verify
# ์์ค ์ฝ๋ ๋ณต์ฌ
COPY . .
# ๋น๋ ์ธ์
ARG VERSION=dev
ARG BUILD_TIME
# ์ต์ ํ๋ ๋น๋
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
-ldflags="-w -s -X main.Version=${VERSION} -X main.BuildTime=${BUILD_TIME}" \
-a -installsuffix cgo \
-o todo-api .
# ์คํ ์คํ
์ด์ง
FROM alpine:latest
# ๋ณด์ ์
๋ฐ์ดํธ
RUN apk --no-cache add ca-certificates tzdata && \
apk upgrade --no-cache
# ์ผ๋ฐ ์ฌ์ฉ์ ์์ฑ
RUN addgroup -g 1000 appgroup && \
adduser -D -u 1000 -G appgroup appuser
WORKDIR /home/appuser
# ๋ฐ์ด๋๋ฆฌ ๋ณต์ฌ
COPY --from=builder /app/todo-api .
# ๊ถํ ์ค์
RUN chown appuser:appgroup todo-api && \
chmod +x todo-api
# ์ผ๋ฐ ์ฌ์ฉ์๋ก ์ ํ
USER appuser
# ํฌํธ ๋
ธ์ถ
EXPOSE 8080
# ํฌ์ค์ฒดํฌ
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1
# ์คํ
CMD ["./todo-api"]
์ฌ๊ธฐ์ ์ฃผ๋ชฉํ ์ ๋ค:
2. HEALTHCHECK: ์ปจํ ์ด๋ ์ํ ์๋ ๋ชจ๋ํฐ๋ง
3. Non-root ์ฌ์ฉ์: ๋ณด์ ๊ฐํ
4. ํ์์กด ๋ฐ์ดํฐ: ์๊ฐ ๊ด๋ จ ๊ธฐ๋ฅ ์ ์ ์๋
5. ๋ฉํฐ ์ํคํ ์ฒ: GOARCH ๋ช ์๋ก ๋ค์ํ ํ๋ซํผ ์ง์ ๊ฐ๋ฅ
๐ ๋น๋ ๋ฐ ์คํ
# ๋น๋
docker build \
--build-arg VERSION=1.0.0 \
--build-arg BUILD_TIME=$(date -u +"%Y-%m-%dT%H:%M:%SZ") \
-t todo-api:1.0.0 \
.
# ์คํ
docker run -d \
--name todo-api \
-p 8080:8080 \
--restart unless-stopped \
todo-api:1.0.0
# ํ
์คํธ
curl http://localhost:8080/health
# ์ถ๋ ฅ: OK
curl http://localhost:8080/version
# ์ถ๋ ฅ: {"version":"1.0.0","build_time":"2024-01-15T10:30:00Z"}
# TODO ์์ฑ
curl -X POST http://localhost:8080/todos \
-H "Content-Type: application/json" \
-d '{"title":"Docker ๊ณต๋ถํ๊ธฐ","completed":false}'
# TODO ๋ชฉ๋ก ์กฐํ
curl http://localhost:8080/todos
์๋ฒฝํ๊ฒ ์๋ํ์ง? ๐ ์ด์ ์ด ์ด๋ฏธ์ง๋ฅผ Docker Hub๋ ํ๋ผ์ด๋น ๋ ์ง์คํธ๋ฆฌ์ ํธ์ํ๋ฉด ์ด๋์๋ ๋ฐฐํฌํ ์ ์์ด!
๐ Docker Compose๋ก ๊ฐ๋ฐ ํ๊ฒฝ ๊ตฌ์ฑ
์ค์ ๊ฐ๋ฐํ ๋๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ Redis ๊ฐ์ ๋ค๋ฅธ ์๋น์ค๋ค๊ณผ ํจ๊ป ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์? Docker Compose๋ฅผ ์ฌ์ฉํ๋ฉด ์ฌ๋ฌ ์ปจํ ์ด๋๋ฅผ ํ ๋ฒ์ ๊ด๋ฆฌํ ์ ์์ด! ๐ญ
๐ docker-compose.yml ์์ฑ
version: '3.8'
services:
# Go ์ ํ๋ฆฌ์ผ์ด์
app:
build:
context: .
dockerfile: Dockerfile
args:
VERSION: ${VERSION:-dev}
BUILD_TIME: ${BUILD_TIME:-unknown}
ports:
- "8080:8080"
environment:
- PORT=8080
- DB_HOST=postgres
- DB_PORT=5432
- DB_USER=todouser
- DB_PASSWORD=todopass
- DB_NAME=tododb
- REDIS_HOST=redis
- REDIS_PORT=6379
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_started
networks:
- app-network
restart: unless-stopped
# PostgreSQL ๋ฐ์ดํฐ๋ฒ ์ด์ค
postgres:
image: postgres:15-alpine
environment:
- POSTGRES_USER=todouser
- POSTGRES_PASSWORD=todopass
- POSTGRES_DB=tododb
volumes:
- postgres-data:/var/lib/postgresql/data
ports:
- "5432:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U todouser"]
interval: 10s
timeout: 5s
retries: 5
networks:
- app-network
# Redis ์บ์
redis:
image: redis:7-alpine
ports:
- "6379:6379"
volumes:
- redis-data:/data
networks:
- app-network
command: redis-server --appendonly yes
volumes:
postgres-data:
redis-data:
networks:
app-network:
driver: bridge
์ด์ ํ ๋ฒ์ ๋ชจ๋ ์๋น์ค๋ฅผ ์คํํ ์ ์์ด:
# ๋ชจ๋ ์๋น์ค ์์ docker-compose up -d # ๋ก๊ทธ ํ์ธ docker-compose logs -f app # ํน์ ์๋น์ค๋ง ์ฌ์์ docker-compose restart app # ๋ชจ๋ ์๋น์ค ์ค์ง ๋ฐ ์ญ์ docker-compose down # ๋ณผ๋ฅจ๊น์ง ์ญ์ docker-compose down -v
๊ฐ๋ฐํ ๋ ์ ๋ง ํธํ์ง? ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ค์นํ๊ณ ์ค์ ํ๊ณ ๊ทธ๋ด ํ์ ์์ด docker-compose up ํ ๋ฒ์ด๋ฉด ๋! ๐
๐ง ๊ฐ๋ฐ ๋ชจ๋์ ํ๋ก๋์ ๋ชจ๋ ๋ถ๋ฆฌ
๊ฐ๋ฐํ ๋์ ๋ฐฐํฌํ ๋ ์ค์ ์ด ๋ค๋ฅผ ์ ์์์? ๊ทธ๋ด ๋๋ ํ์ผ์ ๋ถ๋ฆฌํด:
# docker-compose.dev.yml (๊ฐ๋ฐ์ฉ)
version: '3.8'
services:
app:
build:
context: .
dockerfile: Dockerfile.dev # ๊ฐ๋ฐ์ฉ Dockerfile
volumes:
- .:/app # ์์ค ์ฝ๋ ๋ง์ดํธ (ํซ ๋ฆฌ๋ก๋)
environment:
- GO_ENV=development
- DEBUG=true
ports:
- "8080:8080"
- "2345:2345" # ๋๋ฒ๊ฑฐ ํฌํธ
# docker-compose.prod.yml (ํ๋ก๋์
์ฉ)
version: '3.8'
services:
app:
build:
context: .
dockerfile: Dockerfile
args:
VERSION: ${VERSION}
BUILD_TIME: ${BUILD_TIME}
environment:
- GO_ENV=production
- DEBUG=false
deploy:
replicas: 3 # 3๊ฐ ์ธ์คํด์ค ์คํ
resources:
limits:
cpus: '0.5'
memory: 512M
reservations:
cpus: '0.25'
memory: 256M
์ฌ์ฉํ ๋:
# ๊ฐ๋ฐ ํ๊ฒฝ docker-compose -f docker-compose.yml -f docker-compose.dev.yml up # ํ๋ก๋์ ํ๊ฒฝ docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d
์ด๋ ๊ฒ ํ๋ฉด ํ๊ฒฝ๋ณ๋ก ๊น๋ํ๊ฒ ๊ด๋ฆฌํ ์ ์์ด! ๐ฏ
๐ ์ฑ๋ฅ ๋ชจ๋ํฐ๋ง๊ณผ ์ต์ ํ
์ปจํ ์ด๋๋ฅผ ๋ฐฐํฌํ๋ค๊ณ ๋์ด ์๋์ผ! ์ค์ ๋ก ์ผ๋ง๋ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ๋์ง, ์ฑ๋ฅ์ ์ด๋ค์ง ๋ชจ๋ํฐ๋งํด์ผ ํด. ๐
๐ ๋ฆฌ์์ค ์ฌ์ฉ๋ ํ์ธ
# ์ค์๊ฐ ๋ฆฌ์์ค ์ฌ์ฉ๋ docker stats # ํน์ ์ปจํ ์ด๋๋ง docker stats todo-api # ์ถ๋ ฅ ์์: CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O abc123def456 todo-api 0.05% 8.5MiB / 512MiB 1.66% 1.2kB / 850B
๋ณด๋ค์ํผ Go ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๋ง ์ ๊ฒ ๋จน์ด! 8.5MB๋ฐ์ ์ ์จ. Node.js๋ Java ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ณดํต ์๋ฐฑ MB๋ฅผ ์ฐ๋๋ฐ ๋ง์ด์ผ. ์ด๊ฒ Go์ ํฐ ์ฅ์ ์ด์ง! ๐ช
๐ฏ ๋ฆฌ์์ค ์ ํ ์ค์
์ปจํ ์ด๋๊ฐ ์์คํ ๋ฆฌ์์ค๋ฅผ ๋ ์ ํ์ง ์๋๋ก ์ ํ์ ๊ฑธ์ด์ค์ผ ํด:
# CPU์ ๋ฉ๋ชจ๋ฆฌ ์ ํ
docker run -d \
--name todo-api \
--cpus="0.5" \
--memory="256m" \
--memory-swap="512m" \
-p 8080:8080 \
todo-api:1.0.0
# ๋๋ docker-compose.yml์์
services:
app:
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
reservations:
cpus: '0.25'
memory: 128M
- CPU: 0.5~1 ์ฝ์ด
- Memory: 256MB~512MB
ํ๋ก๋์ ํ๊ฒฝ (ํธ๋ํฝ์ ๋ฐ๋ผ):
- ๋ฎ์ ํธ๋ํฝ: CPU 0.5 ์ฝ์ด, Memory 256MB
- ์ค๊ฐ ํธ๋ํฝ: CPU 1 ์ฝ์ด, Memory 512MB
- ๋์ ํธ๋ํฝ: CPU 2+ ์ฝ์ด, Memory 1GB+
Go ์ ํ๋ฆฌ์ผ์ด์ ์ ํจ์จ์ ์ด๋ผ์ ์๊ฐ๋ณด๋ค ์ ์ ๋ฆฌ์์ค๋ก๋ ์ถฉ๋ถํด!
๐ฅ ํ๋กํ์ผ๋ง์ผ๋ก ๋ณ๋ชฉ ์ง์ ์ฐพ๊ธฐ
Go๋ ๋ด์ฅ ํ๋กํ์ผ๋ง ๋๊ตฌ๊ฐ ์ ๋ง ํ๋ฅญํด! ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋จํ ์ถ๊ฐํ ์ ์์ด:
package main
import (
"log"
"net/http"
_ "net/http/pprof" // ํ๋กํ์ผ๋ง ์๋ํฌ์ธํธ ์๋ ๋ฑ๋ก
)
func main() {
// ํ๋กํ์ผ๋ง ์๋ฒ (๊ฐ๋ฐ/์คํ
์ด์ง ํ๊ฒฝ์์๋ง!)
go func() {
log.Println("Profiling server on :6060")
log.Println(http.ListenAndServe(":6060", nil))
}()
// ๋ฉ์ธ ์ ํ๋ฆฌ์ผ์ด์
...
http.HandleFunc("/", handler)
log.Fatal(http.ListenAndServe(":8080", nil))
}
์ด์ ํ๋กํ์ผ๋ง ๋ฐ์ดํฐ๋ฅผ ์์งํ ์ ์์ด:
# CPU ํ๋กํ์ผ (30์ด๊ฐ ์์ง) curl http://localhost:6060/debug/pprof/profile?seconds=30 > cpu.prof # ๋ฉ๋ชจ๋ฆฌ ํ๋กํ์ผ curl http://localhost:6060/debug/pprof/heap > mem.prof # ๊ณ ๋ฃจํด ์ํ curl http://localhost:6060/debug/pprof/goroutine > goroutine.prof # ๋ถ์ go tool pprof cpu.prof # (pprof) top10 # ์์ 10๊ฐ ํจ์ # (pprof) web # ๋ธ๋ผ์ฐ์ ์์ ์๊ฐํ
์ด๋ ๊ฒ ํ๋ฉด ์ด๋ ํจ์๊ฐ CPU๋ฅผ ๋ง์ด ์ฐ๋์ง, ๋ฉ๋ชจ๋ฆฌ ๋์๋ ์๋์ง ์ ํํ ์ ์ ์์ด! ๐ฏ
๐ CI/CD ํ์ดํ๋ผ์ธ ๊ตฌ์ถ
์ด์ ์๋ํ๋ ๋น๋์ ๋ฐฐํฌ ํ์ดํ๋ผ์ธ์ ๋ง๋ค์ด๋ณด์! GitHub Actions๋ฅผ ์๋ก ๋ค์ด๋ณผ๊ฒ. ๐
๐ง GitHub Actions ์ํฌํ๋ก์ฐ
.github/workflows/docker-build.yml ํ์ผ์ ๋ง๋ค์ด:
name: Docker Build and Push
on:
push:
branches: [ main, develop ]
tags: [ 'v*' ]
pull_request:
branches: [ main ]
env:
REGISTRY: ghcr.io
IMAGE_NAME: ${{ github.repository }}
jobs:
build:
runs-on: ubuntu-latest
permissions:
contents: read
packages: write
steps:
- name: Checkout ์ฝ๋
uses: actions/checkout@v3
- name: Docker ๋ฉํ๋ฐ์ดํฐ ์ค์
id: meta
uses: docker/metadata-action@v4
with:
images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
tags: |
type=ref,event=branch
type=ref,event=pr
type=semver,pattern={{version}}
type=semver,pattern={{major}}.{{minor}}
type=sha
- name: Docker Buildx ์ค์
uses: docker/setup-buildx-action@v2
- name: ๋ ์ง์คํธ๋ฆฌ ๋ก๊ทธ์ธ
uses: docker/login-action@v2
with:
registry: ${{ env.REGISTRY }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: ๋น๋ ๋ฐ ํธ์
uses: docker/build-push-action@v4
with:
context: .
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}
build-args: |
VERSION=${{ steps.meta.outputs.version }}
BUILD_TIME=${{ github.event.head_commit.timestamp }}
GIT_COMMIT=${{ github.sha }}
cache-from: type=gha
cache-to: type=gha,mode=max
- name: ์ด๋ฏธ์ง ์ค์บ
uses: aquasecurity/trivy-action@master
with:
image-ref: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.meta.outputs.version }}
format: 'sarif'
output: 'trivy-results.sarif'
- name: ์ค์บ ๊ฒฐ๊ณผ ์
๋ก๋
uses: github/codeql-action/upload-sarif@v2
with:
sarif_file: 'trivy-results.sarif'
์ด ์ํฌํ๋ก์ฐ๋:
2. ํ๊ทธ ๊ธฐ๋ฐ ๋ฒ์ ๊ด๋ฆฌ: v1.0.0 ๊ฐ์ ํ๊ทธ๋ฅผ ๋ฌ๋ฉด ํด๋น ๋ฒ์ ์ผ๋ก ์ด๋ฏธ์ง ์์ฑ
3. ์บ์ ํ์ฉ: GitHub Actions ์บ์๋ก ๋น๋ ์๋ ํฅ์
4. ์๋ ๋ณด์ ์ค์บ: Trivy๋ก ์ทจ์ฝ์ ์๋ ๊ฒ์ฌ
5. ๋ฉํฐ ํ๋ซํผ ์ง์: AMD64, ARM64 ๋ฑ ์ฌ๋ฌ ์ํคํ ์ฒ ๋์ ๋น๋ ๊ฐ๋ฅ
๐ ๋ฉํฐ ํ๋ซํผ ๋น๋
์์ฆ์ ARM ๊ธฐ๋ฐ ์๋ฒ(AWS Graviton, Apple Silicon ๋ฑ)๋ ๋ง์ด ์ฐ์์? ๋ฉํฐ ํ๋ซํผ ์ด๋ฏธ์ง๋ฅผ ๋ง๋ค๋ฉด ์ด๋์๋ ์คํํ ์ ์์ด:
# ๋ก์ปฌ์์ ๋ฉํฐ ํ๋ซํผ ๋น๋ docker buildx create --name multiplatform --use docker buildx inspect --bootstrap # AMD64์ ARM64 ๋์ ๋น๋ docker buildx build \ --platform linux/amd64,linux/arm64 \ -t myapp:latest \ --push \ .
GitHub Actions์์๋:
- name: ๋น๋ ๋ฐ ํธ์ (๋ฉํฐ ํ๋ซํผ)
uses: docker/build-push-action@v4
with:
context: .
platforms: linux/amd64,linux/arm64
push: true
tags: ${{ steps.meta.outputs.tags }}
์ด๋ ๊ฒ ํ๋ฉด Intel ์๋ฒ๋ ARM ์๋ฒ๋ ์๊ด์์ด ๊ฐ์ ์ด๋ฏธ์ง๋ฅผ ์ฌ์ฉํ ์ ์์ด! ๐
๐ ์ค์ ํ๊ณผ ๋ฒ ์คํธ ํ๋ํฐ์ค
์ง๊ธ๊น์ง ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ์ค์ ์์ ์ ์ฉํ ํ๋ค์ ์ ๋ฆฌํด๋ณผ๊ฒ! ์ด๊ฑด ๋ด๊ฐ ์ค์ ๋ก ํ๋ก์ ํธํ๋ฉด์ ๋ฐฐ์ด ๊ฒ๋ค์ด์ผ. ๐
โ ์ฒดํฌ๋ฆฌ์คํธ
| ํญ๋ชฉ | ์ค๋ช | ์ค์๋ |
|---|---|---|
| ๋ฉํฐ์คํ ์ด์ง ๋น๋ | ๋น๋์ ๋ฐํ์ ๋ถ๋ฆฌ๋ก ์ด๋ฏธ์ง ํฌ๊ธฐ ์ต์ํ | โญโญโญโญโญ |
| .dockerignore | ๋ถํ์ํ ํ์ผ ์ ์ธ๋ก ๋น๋ ์๋ ํฅ์ | โญโญโญโญโญ |
| ๋ ์ด์ด ์บ์ฑ | ์์กด์ฑ ํ์ผ ๋จผ์ ๋ณต์ฌํ์ฌ ์บ์ ํ์ฉ | โญโญโญโญโญ |
| Non-root ์ฌ์ฉ์ | ๋ณด์ ๊ฐํ๋ฅผ ์ํ ์ผ๋ฐ ์ฌ์ฉ์ ์คํ | โญโญโญโญโญ |
| ํฌ์ค์ฒดํฌ | ์ปจํ ์ด๋ ์ํ ์๋ ๋ชจ๋ํฐ๋ง | โญโญโญโญ |
| ๋ฒ์ ํ๊น | ๋ช ํํ ๋ฒ์ ๊ด๋ฆฌ์ ๋กค๋ฐฑ ๊ฐ๋ฅ | โญโญโญโญ |
| ๋ฆฌ์์ค ์ ํ | CPU/๋ฉ๋ชจ๋ฆฌ ์ ํ์ผ๋ก ์์ ์ฑ ํ๋ณด | โญโญโญโญ |
| ๋ณด์ ์ค์บ | ์ ๊ธฐ์ ์ธ ์ทจ์ฝ์ ๊ฒ์ฌ | โญโญโญโญ |
| ๋ก๊น ์ค์ | ๊ตฌ์กฐํ๋ ๋ก๊ทธ๋ก ๋๋ฒ๊น ์ฉ์ด | โญโญโญ |
| ํ๊ฒฝ ๋ณ์ | ์ค์ ์ธ๋ถํ๋ก ์ ์ฐ์ฑ ํ๋ณด | โญโญโญ |
๐ฏ ์ด๋ฏธ์ง ํ๊น ์ ๋ต
์ด๋ฏธ์ง ํ๊ทธ๋ฅผ ์ด๋ป๊ฒ ๊ด๋ฆฌํ๋๋๊ฐ ์ ๋ง ์ค์ํด! ๋ด๊ฐ ์ถ์ฒํ๋ ์ ๋ต์:
# ๊ฐ๋ฐ ํ๊ฒฝ myapp:dev myapp:dev-20240115 myapp:dev-abc123 # Git ์ปค๋ฐ ํด์ # ์คํ ์ด์ง ํ๊ฒฝ myapp:staging myapp:staging-1.2.3-rc1 # ํ๋ก๋์ ํ๊ฒฝ myapp:latest # ์ต์ ์์ ๋ฒ์ myapp:1.2.3 # ์ ํํ ๋ฒ์ myapp:1.2 # ๋ง์ด๋ ๋ฒ์ myapp:1 # ๋ฉ์ด์ ๋ฒ์ myapp:stable # ์์ ๋ฒ์ ๋ณ์นญ
2. ์๋งจํฑ ๋ฒ์ ๋: major.minor.patch ํ์ ์ค์
3. Git ์ปค๋ฐ ํด์ ํฌํจ: ์ถ์ ์ฑ ํ๋ณด
4. ํ๊ฒฝ๋ณ ํ๊ทธ: dev, staging, prod ๊ตฌ๋ถ
5. ๋ถ๋ณ์ฑ: ๊ฐ์ ํ๊ทธ๋ฅผ ๋ฎ์ด์ฐ์ง ๋ง๊ณ ์ ๋ฒ์ ์์ฑ
๐ ๋๋ฒ๊น ํ
์ปจํ ์ด๋ ์์์ ๋ฌธ์ ๊ฐ ์๊ฒผ์ ๋ ๋๋ฒ๊น ํ๋ ๋ฐฉ๋ฒ๋ค:
# ์ปจํ ์ด๋ ๋ก๊ทธ ํ์ธ docker logs todo-api docker logs -f todo-api # ์ค์๊ฐ ๋ก๊ทธ docker logs --tail 100 todo-api # ์ต๊ทผ 100์ค # ์ปจํ ์ด๋ ์์ผ๋ก ๋ค์ด๊ฐ๊ธฐ (alpine ๊ธฐ๋ฐ) docker exec -it todo-api sh # ์ปจํ ์ด๋ ์์ผ๋ก ๋ค์ด๊ฐ๊ธฐ (scratch ๊ธฐ๋ฐ์ ๋ถ๊ฐ๋ฅ!) # ๋์ ๋๋ฒ๊ทธ์ฉ ์ด๋ฏธ์ง ๋ฐ๋ก ๋น๋ FROM alpine:latest AS debug COPY --from=builder /app/main . RUN apk add --no-cache bash curl vim CMD ["sh"] # ์คํ ์ค์ธ ํ๋ก์ธ์ค ํ์ธ docker top todo-api # ์ปจํ ์ด๋ ์์ธ ์ ๋ณด docker inspect todo-api # ํ์ผ ์์คํ ๋ณ๊ฒฝ ์ฌํญ docker diff todo-api # ์ปจํ ์ด๋์์ ํ์ผ ๋ณต์ฌ docker cp todo-api:/var/log/app.log ./app.log
๐ ๋ก๊น ๋ฒ ์คํธ ํ๋ํฐ์ค
Go ์ ํ๋ฆฌ์ผ์ด์ ์์ ๊ตฌ์กฐํ๋ ๋ก๊น ์ ์ฌ์ฉํ๋ฉด ๋์ค์ ๋ถ์ํ๊ธฐ ํจ์ฌ ์ฌ์:
package main
import (
"log/slog"
"os"
)
func main() {
// JSON ํ์ ๋ก๊ฑฐ ์ค์
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
Level: slog.LevelInfo,
}))
// ๊ธฐ๋ณธ ๋ก๊ฑฐ๋ก ์ค์
slog.SetDefault(logger)
// ๊ตฌ์กฐํ๋ ๋ก๊น
slog.Info("์๋ฒ ์์",
"port", 8080,
"version", "1.0.0",
"environment", "production",
)
// ์๋ฌ ๋ก๊น
if err := doSomething(); err != nil {
slog.Error("์์
์คํจ",
"error", err,
"operation", "doSomething",
"user_id", 12345,
)
}
}
์ด๋ ๊ฒ ํ๋ฉด ๋ก๊ทธ๊ฐ JSON ํ์์ผ๋ก ์ถ๋ ฅ๋์ด์ Elasticsearch, Splunk ๊ฐ์ ๋ก๊ทธ ๋ถ์ ๋๊ตฌ๋ก ์ฝ๊ฒ ์์งํ๊ณ ๋ถ์ํ ์ ์์ด! ๐
๐ ์ฌ๋ฅ๋ท์์ Docker ์ ๋ฌธ๊ฐ ์ฐพ๊ธฐ
์ฌ๊ธฐ๊น์ง ์ฝ์๋ค๋ฉด Go์ Docker์ ๋ํด ๊ฝค ๋ง์ด ์๊ฒ ๋์ ๊ฑฐ์ผ! ํ์ง๋ง ์ค์ ํ๋ก์ ํธ์์๋ ์์์น ๋ชปํ ๋ฌธ์ ๋ค์ด ์๊ธฐ๊ธฐ ๋ง๋ จ์ด์ง. ๐ค
ํน์ Docker ์ปจํ ์ด๋ํ๋ Kubernetes ๋ฐฐํฌ, CI/CD ํ์ดํ๋ผ์ธ ๊ตฌ์ถ ๊ฐ์ ๊ฑธ ๋์์ค ์ ๋ฌธ๊ฐ๊ฐ ํ์ํ๋ค๋ฉด ์ฌ๋ฅ๋ท์ ํ์ฉํด๋ด! ์ฌ๋ฅ๋ท์๋ ์ค๋ฌด ๊ฒฝํ์ด ํ๋ถํ DevOps ์์ง๋์ด๋ค์ด ๋ง๊ฑฐ๋ . 1:1 ์ปจ์คํ ๋ถํฐ ํ๋ก์ ํธ ์ ์ฒด ๊ตฌ์ถ๊น์ง ๋ค์ํ ์๋น์ค๋ฅผ ๋ฐ์ ์ ์์ด. ๐ผ
ํนํ ์ด๊ธฐ ์คํํธ์ ์ด๋ ๊ฐ์ธ ๊ฐ๋ฐ์๋ค์ ์ธํ๋ผ ๊ตฌ์ถ์ ์๊ฐ์ ๋ง์ด ์ฐ๊ธฐ๋ณด๋ค๋ ํต์ฌ ๋น์ฆ๋์ค ๋ก์ง ๊ฐ๋ฐ์ ์ง์คํ๋ ๊ฒ ์ข์์? ๊ทธ๋ด ๋ ์ฌ๋ฅ๋ท์ ์ ๋ฌธ๊ฐ๋คํํ ๋์์ ๋ฐ์ผ๋ฉด ์๊ฐ๊ณผ ๋น์ฉ์ ํฌ๊ฒ ์ ์ฝํ ์ ์์ด! ๐
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ค๋ ์ฐ๋ฆฌ๊ฐ ๋ญ ๋ฐฐ์ ๋์ง ์ ๋ฆฌํด๋ณผ๊น? ๐ค
- ์ ์ ์ปดํ์ผ๋ก ์์กด์ฑ ์๋ ๋จ์ผ ๋ฐ์ด๋๋ฆฌ
- ๋ฉํฐ์คํ ์ด์ง ๋น๋๋ก 98% ์ด์ ํฌ๊ธฐ ๊ฐ์
- Alpine์ด๋ Scratch ๋ฒ ์ด์ค๋ก ์ด๊ฒฝ๋ ์ด๋ฏธ์ง
2. ์ต์ ํ ์ ๋ต
- ๋ ์ด์ด ์บ์ฑ์ผ๋ก ๋น๋ ์๋ 10๋ฐฐ ํฅ์
- .dockerignore๋ก ๋ถํ์ํ ํ์ผ ์ ์ธ
- CGO_ENABLED=0์ผ๋ก ์์ Go ๋ฐ์ด๋๋ฆฌ
3. ๋ณด์ ๊ฐํ
- Non-root ์ฌ์ฉ์๋ก ์คํ
- ์ ๊ธฐ์ ์ธ ์ทจ์ฝ์ ์ค์บ
- ๋ฏผ๊ฐ ์ ๋ณด๋ ํ๊ฒฝ ๋ณ์๋ Secrets ์ฌ์ฉ
4. ์ด์ ์๋ํ
- Docker Compose๋ก ๋ก์ปฌ ๊ฐ๋ฐ ํ๊ฒฝ ๊ตฌ์ฑ
- CI/CD ํ์ดํ๋ผ์ธ์ผ๋ก ์๋ ๋น๋/๋ฐฐํฌ
- ํฌ์ค์ฒดํฌ์ ๋ชจ๋ํฐ๋ง์ผ๋ก ์์ ์ฑ ํ๋ณด
์ฒ์์๋ ๋ณต์กํด ๋ณด์ผ ์ ์์ง๋ง, ํ ๋ฒ ์ ๋๋ก ์ค์ ํด๋๋ฉด ์ ๋ง ํธํด! ์ฝ๋ ํธ์ํ๋ฉด ์๋์ผ๋ก ๋น๋๋๊ณ , ํ ์คํธ๋๊ณ , ๋ฐฐํฌ๋๋ ๊ฑธ ๋ณด๋ฉด ๋ฟ๋ฏํ๊ฑฐ๋ . ๐
Go ์ธ์ด์ ํจ์จ์ฑ๊ณผ Docker์ ์ด์์ฑ์ ๊ฒฐํฉํ๋ฉด ์ ๋ง ๊ฐ๋ ฅํ ์์คํ ์ ๋ง๋ค ์ ์์ด. ํนํ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ ์ฒ๋ ํด๋ผ์ฐ๋ ๋ค์ดํฐ๋ธ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋ฐํ ๋๋ ํ์์ ์ธ ๊ธฐ์ ์ด์ง!
์ด ๊ธ์ด ๋์์ด ๋๊ธฐ๋ฅผ ๋ฐ๋ผ! ๊ถ๊ธํ ์ ์ด ์๊ฑฐ๋ ๋ ๊น์ด ์๋ ๋ด์ฉ์ด ํ์ํ๋ฉด ์ฌ๋ฅ๋ท์์ ์ ๋ฌธ๊ฐ๋ค๊ณผ ์๋ดํด๋ณด๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ. ์ค์ ๊ฒฝํ์ด ํ๋ถํ ์ฌ๋๋คํํ ๋ฐฐ์ฐ๋ฉด ํจ์ฌ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ ์ ์๊ฑฐ๋ ! ๐ฑ
์, ์ด์ ์ง์ ํด๋ณด์! ๊ฐ๋จํ Go ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ค๊ณ Docker๋ก ์ปจํ ์ด๋ํํด๋ด. ์ฒ์์๋ ๊ธฐ๋ณธ Dockerfile๋ก ์์ํด์ ์ ์ ์ต์ ํํด๋๊ฐ๋ฉด์ ์ด๋ฏธ์ง ํฌ๊ธฐ๊ฐ ์ค์ด๋๋ ๊ฑธ ํ์ธํด๋ด. ์ ๋ง ์ฌ๋ฏธ์์ ๊ฑฐ์ผ! ๐
Happy Coding! ๊ทธ๋ฆฌ๊ณ Happy Dockerizing! ๐ณโจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.