Static Binaries และ Go Toolchain

Node.js: runtime + node_modules

เมื่อคุณจะ ship แอป TypeScript/Node.js คุณต้องเตรียมสิ่งเหล่านี้:

Node.js runtime (เวอร์ชันที่ถูกต้อง — จัดการด้วย .nvmrc, Docker base image ฯลฯ)
ทุก npm package ที่โค้ดของคุณพึ่งพา (node_modules/ — มักมีขนาดหลายร้อย MB)
ขั้นตอน transpile (tsc, esbuild, swc ฯลฯ) เพื่อแปลง TypeScript เป็น JavaScript

การ deploy หมายถึงการทำให้แน่ใจว่าทั้งสามชิ้นส่วนนี้มีครบและเวอร์ชันตรงกันบนทุกเครื่องปลายทาง

Go: binary เดียว ไม่ต้องมี runtime

โปรแกรม Go คอมไพล์ออกมาเป็น static binary เดี่ยว ที่บรรจุโค้ดของคุณ, dependencies ทั้งหมด และ Go runtime ไว้ในตัว — ลิงก์รวมเข้าไปทั้งหมด เครื่องปลายทางไม่ต้องติดตั้งอะไรเพิ่มเลย ไม่ต้องมี Go ติดตั้ง ไม่ต้องมี package manager ไม่ต้องมี interpreter

# TypeScript deployment checklist
# 1. Install Node.js (exact version)
node --version   # must match .nvmrc

# 2. Install dependencies
npm install      # downloads node_modules/ (~hundreds of MB)

# 3. Build
npx tsc --build

# 4. Run
node dist/index.js

# Dockerfile must include:
# FROM node:20-alpine
# COPY package*.json ./
# RUN npm ci
# COPY dist/ ./dist/
# CMD ["node", "dist/index.js"]

# Go deployment checklist
# 1. Build
go build -o myapp ./cmd/myapp

# 2. Copy binary to target (that's it)
scp myapp user@server:/usr/local/bin/

# 3. Run
./myapp

# Dockerfile can be:
# FROM scratch          <-- empty base image!
# COPY myapp /myapp
# CMD ["/myapp"]
#
# Final image is often < 10 MB vs 200–500 MB for Node

Cross-compilation ด้วยคำสั่งเดียว

Go มี cross-compilation มาในตัว แค่ตั้งค่า GOOS (OS ปลายทาง) และ GOARCH (CPU ปลายทาง) เป็น environment variables แล้วรัน go build ไม่ต้องมี toolchain เพิ่ม ไม่ต้อง emulate ด้วย Docker ไม่ต้องมีขั้นตอน CI แยกสำหรับแต่ละ platform

# TypeScript cross-platform is handled by Node.js itself
# But native addons (node-gyp, .node files) break cross-platform
# pkg / nexe / sea bundle Node + app, but are complex and large

# Build for Linux amd64 on a Mac
GOOS=linux   GOARCH=amd64  go build -o myapp-linux    ./cmd/myapp

# Build for Windows
GOOS=windows GOARCH=amd64  go build -o myapp.exe       ./cmd/myapp

# Build for ARM (Raspberry Pi, AWS Graviton, Apple Silicon)
GOOS=linux   GOARCH=arm64  go build -o myapp-arm64     ./cmd/myapp

# All three commands run on your laptop — no emulation needed
# Each output is a standalone executable for that platform

เวลา compile ที่รวดเร็ว

Go ออกแบบมาโดยตั้งความเร็วในการ compile เป็นเป้าหมายระดับ first-class โค้ดเบสขนาดใหญ่ที่อาจใช้เวลาหลายนาทีใน C++ หรือแม้แต่หลายวินาทีใน TypeScript (รัน tsc แบบเต็ม) จะ compile เสร็จในไม่กี่วินาทีหรือต่ำกว่าวินาทีใน Go เพราะ standard library ถูก pre-compile ไว้แล้ว, dependency graph ชัดเจน และไม่มี overhead จากการตรวจจับ circular import

# TypeScript build times (realistic examples)
# tsc --build on a medium NestJS project: 5–30s
# esbuild (fastest TS bundler): 0.5–3s
# But: tsc is also used for type-checking only (no emit)
# Type-check of a large monorepo: 30s–3min

# Go build times
# go build ./...  on a medium service: < 2s
# go test ./...   (build + run tests):  2–10s
# go vet ./...    (static analysis):    < 1s

# The toolchain is one binary — no plugin ecosystem needed:
go build   # compile
go test    # test
go vet     # static analysis
go fmt     # format (gofmt — no config needed)
go mod     # dependency management

🟦 Static Binary — What Gets Linked In

โดยค่าเริ่มต้น go build จะสร้าง binary แบบ statically linked บน platform ส่วนใหญ่ ทุกอย่างที่โปรแกรมของคุณต้องใช้จะถูกฝัง (embed) เข้าไป:

โค้ดแอปพลิเคชันของคุณ
ทุก package ที่ import เข้ามา (รวมถึง third-party modules)
Go runtime (scheduler, GC, การจัดการ goroutine stack)
package ของ standard library ที่คุณใช้

ข้อยกเว้นเดียวคือโปรแกรมที่ใช้ cgo (เรียก C libraries ผ่านกลไก import "C") ซึ่งจะทำให้เกิด dynamic linking ไปยัง libc สำหรับโปรแกรม Go ล้วน ๆ แล้ว binary จะมีทุกอย่างครบในตัวอย่างสมบูรณ์

# Verify your binary has no dynamic dependencies:
$ ldd ./myapp
    not a dynamic executable    # ← pure Go: static!

# For cgo programs, force static linking:
CGO_ENABLED=0 go build -o myapp ./cmd/myapp

flag CGO_ENABLED=0 สำคัญมากสำหรับ Docker image แบบ FROM scratch

🟦 go mod — Reproducible Dependency Management

Go modules (go.mod / go.sum) คือคำตอบของ Go ที่เทียบได้กับ package.json / package-lock.json ไฟล์ go.sum เก็บ cryptographic checksum ของ source code ในทุก dependency ไว้ รับประกันว่าจะดึง source tree ชุดเดิมมาทุกครั้งบนทุกเครื่อง

# go.mod — direct dependencies only
module github.com/example/myapp

go 1.22

require (
    github.com/gin-gonic/gin v1.9.1
    github.com/jackc/pgx/v5  v5.5.0
)

# go.sum — cryptographic checksums (committed to version control)
# Ensures supply-chain integrity — no mutable "latest" pulls

ต่างจาก npm ตรงที่ไม่มี central registry ที่คุณต้องเชื่อถืออย่างไม่มีเงื่อนไข — ใครก็โฮสต์ Go module ไว้ที่ URL ใดก็ได้ และ go.sum ก็การันตีว่าเนื้อหาจะไม่เปลี่ยนแปลงหลังจากที่คุณดึงมาครั้งแรก

🟦 The Playground Cannot Demonstrate Build Commands

ฟีเจอร์หลักของบทเรียนนี้ — การคอมไพล์เป็น static binary, cross-compilation และการ deploy ด้วย Docker — ไม่สามารถแสดงให้เห็นใน Go playground บน browser ได้ เพราะ playground แค่รันโค้ดเท่านั้น สร้าง binary artifact ไม่ได้

หากต้องการทดลองฟีเจอร์เหล่านี้บนเครื่องของคุณเอง:

# Install Go from https://go.dev/dl/ (one installer, no version manager needed)
go version              # verify install

# Start a new module
mkdir myapp && cd myapp
go mod init github.com/you/myapp

# Write main.go, then:
go build -o myapp .     # static binary in current dir
./myapp                 # run it — no "node" prefix needed

# Cross-compile
GOOS=linux GOARCH=amd64 go build -o myapp-linux .