// main.go
package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Printf("Hello from Go!\n")
    fmt.Printf("OS: %s\n", runtime.GOOS)
    fmt.Printf("Architecture: %s\n", runtime.GOARCH)
}

# Linux나 macOS에서 실행
GOOS=windows GOARCH=amd64 go build -o myapp.exe main.go

# Windows PowerShell에서 실행
$env:GOOS="windows"; $env:GOARCH="amd64"; go build -o myapp.exe main.go

# Intel Mac용 (amd64)
GOOS=darwin GOARCH=amd64 go build -o myapp-mac-intel main.go

# Apple Silicon (M1/M2) Mac용 (arm64)
GOOS=darwin GOARCH=arm64 go build -o myapp-mac-arm main.go

# Linux 64비트용
GOOS=linux GOARCH=amd64 go build -o myapp-linux main.go

# Linux ARM 64비트용 (라즈베리파이 등)
GOOS=linux GOARCH=arm64 go build -o myapp-linux-arm main.go

# Linux 32비트용
GOOS=linux GOARCH=386 go build -o myapp-linux-32 main.go

go tool dist list

// file_windows.go
//go:build windows

package main

import "fmt"

func platformSpecific() {
    fmt.Println("이 코드는 Windows에서만 컴파일됩니다!")
}

// file_linux.go
//go:build linux

package main

import "fmt"

func platformSpecific() {
    fmt.Println("이 코드는 Linux에서만 컴파일됩니다!")
}

# 디버그 정보 제거 및 최적화
go build -ldflags="-s -w" -o myapp main.go

# 더 공격적인 최적화
go build -ldflags="-s -w" -trimpath -o myapp main.go

// main.go
package main

import "fmt"

var (
    version = "dev"
    commit  = "none"
    date    = "unknown"
)

func main() {
    fmt.Printf("Version: %s\n", version)
    fmt.Printf("Commit: %s\n", commit)
    fmt.Printf("Build Date: %s\n", date)
}

# 빌드 시 버전 정보 주입
go build -ldflags="-X main.version=1.0.0 -X main.commit=$(git rev-parse HEAD) -X main.date=$(date +%Y-%m-%d)" -o myapp

CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o myapp main.go

#!/bin/bash
# build.sh

APP_NAME="myapp"
VERSION="1.0.0"
BUILD_DIR="./build"

# 빌드 디렉토리 생성
mkdir -p $BUILD_DIR

# 플랫폼 목록
platforms=(
    "windows/amd64"
    "windows/386"
    "darwin/amd64"
    "darwin/arm64"
    "linux/amd64"
    "linux/386"
    "linux/arm"
    "linux/arm64"
)

for platform in "${platforms[@]}"
do
    platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}
    
    output_name=$APP_NAME'-'$VERSION'-'$GOOS'-'$GOARCH
    
    if [ $GOOS = "windows" ]; then
        output_name+='.exe'
    fi
    
    echo "Building for $GOOS/$GOARCH..."
    
    env GOOS=$GOOS GOARCH=$GOARCH CGO_ENABLED=0 go build \
        -ldflags="-s -w -X main.version=$VERSION" \
        -o $BUILD_DIR/$output_name \
        main.go
    
    if [ $? -ne 0 ]; then
        echo "Failed to build for $GOOS/$GOARCH"
        exit 1
    fi
done

echo "Build completed successfully!"

# Makefile

APP_NAME := myapp
VERSION := 1.0.0
BUILD_DIR := ./build

.PHONY: all clean windows linux darwin

all: clean windows linux darwin

clean:
	rm -rf $(BUILD_DIR)
	mkdir -p $(BUILD_DIR)

windows:
	GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-windows-amd64.exe
	GOOS=windows GOARCH=386 go build -ldflags="-s -w" -o $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-windows-386.exe

linux:
	GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-amd64
	GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-arm64

darwin:
	GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-darwin-amd64
	GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w" -o $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-darwin-arm64

# .goreleaser.yaml

before:
  hooks:
    - go mod tidy

builds:
  - env:
      - CGO_ENABLED=0
    goos:
      - linux
      - windows
      - darwin
    goarch:
      - amd64
      - arm64
    ldflags:
      - -s -w
      - -X main.version={{.Version}}
      - -X main.commit={{.Commit}}
      - -X main.date={{.Date}}

archives:
  - format: tar.gz
    name_template: >-
      {{ .ProjectName }}_
      {{- .Version }}_
      {{- .Os }}_
      {{- .Arch }}
    format_overrides:
      - goos: windows
        format: zip

checksum:
  name_template: 'checksums.txt'

changelog:
  sort: asc

# Dockerfile

# 빌드 스테이지
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 GOARCH=amd64 go build \
    -ldflags="-s -w" \
    -o myapp \
    main.go

# 실행 스테이지
FROM scratch

# 빌드된 바이너리만 복사
COPY --from=builder /app/myapp /myapp

# SSL 인증서 복사 (HTTPS 통신이 필요한 경우)
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/

ENTRYPOINT ["/myapp"]

# 멀티 플랫폼 이미지 빌드
docker buildx build \
    --platform linux/amd64,linux/arm64,linux/arm/v7 \
    -t myapp:latest \
    --push \
    .

# .github/workflows/release.yml

name: Release

on:
  push:
    tags:
      - 'v*'

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: '1.21'
      
      - name: Build
        run: |
          mkdir -p dist
          
          # Windows
          GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o dist/myapp-windows-amd64.exe
          
          # macOS
          GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o dist/myapp-darwin-amd64
          GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w" -o dist/myapp-darwin-arm64
          
          # Linux
          GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o dist/myapp-linux-amd64
          GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o dist/myapp-linux-arm64
      
      - name: Create Release
        uses: softprops/action-gh-release@v1
        with:
          files: dist/*
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

# gomobile 설치
go install golang.org/x/mobile/cmd/gomobile@latest
gomobile init

# Android용 빌드
gomobile bind -target=android -o myapp.aar

# iOS용 빌드
gomobile bind -target=ios -o MyApp.framework

// 잘못된 방법
path := "config\\app.json"  // Windows에서만 작동

// 올바른 방법
import "path/filepath"

path := filepath.Join("config", "app.json")  // 모든 OS에서 작동

package main

import (
    "fmt"
    "runtime"
)

func main() {
    switch runtime.GOOS {
    case "windows":
        // Windows 전용 로직
        fmt.Println("Running on Windows")
    case "darwin":
        // macOS 전용 로직
        fmt.Println("Running on macOS")
    case "linux":
        // Linux 전용 로직
        fmt.Println("Running on Linux")
    default:
        fmt.Println("Unknown OS")
    }
}

// 상세한 로깅 추가
import "log"

log.SetFlags(log.LstdFlags | log.Lshortfile)
log.Printf("OS: %s, Arch: %s", runtime.GOOS, runtime.GOARCH)

// 패닉 복구
defer func() {
    if r := recover(); r != nil {
        log.Printf("Panic recovered: %v", r)
    }
}()

// main.go
package main

import (
    "fmt"
    "runtime"
    "time"
)

type SystemInfo struct {
    OS           string
    Architecture string
    NumCPU       int
    GoVersion    string
}

func getSystemInfo() SystemInfo {
    return SystemInfo{
        OS:           runtime.GOOS,
        Architecture: runtime.GOARCH,
        NumCPU:       runtime.NumCPU(),
        GoVersion:    runtime.Version(),
    }
}

func getMemoryStats() runtime.MemStats {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    return m
}

func main() {
    info := getSystemInfo()
    
    fmt.Println("=== System Information ===")
    fmt.Printf("OS: %s\n", info.OS)
    fmt.Printf("Architecture: %s\n", info.Architecture)
    fmt.Printf("CPU Cores: %d\n", info.NumCPU)
    fmt.Printf("Go Version: %s\n", info.GoVersion)
    
    fmt.Println("\n=== Memory Statistics ===")
    
    for {
        mem := getMemoryStats()
        
        fmt.Printf("\rAlloc: %d MB | TotalAlloc: %d MB | Sys: %d MB | NumGC: %d",
            mem.Alloc/1024/1024,
            mem.TotalAlloc/1024/1024,
            mem.Sys/1024/1024,
            mem.NumGC)
        
        time.Sleep(1 * time.Second)
    }
}

#!/bin/bash
# build-monitor.sh

APP="sysmonitor"
VERSION="1.0.0"

# Windows
GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o ${APP}-windows.exe

# macOS
GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o ${APP}-mac-intel
GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w" -o ${APP}-mac-arm

# Linux
GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o ${APP}-linux

echo "Build completed!"

// server.go
package main

import (
    "fmt"
    "log"
    "net/http"
    "runtime"
)

func handler(w http.ResponseWriter, r *http.Request) {
    info := fmt.Sprintf(`
        <h1>Hello from Go Server!</h1>
        <p>OS: %s</p>
        <p>Architecture: %s</p>
        <p>Go Version: %s</p>
        <p>Request from: %s</p>
    `, runtime.GOOS, runtime.GOARCH, runtime.Version(), r.RemoteAddr)
    
    fmt.Fprintf(w, info)
}

func main() {
    http.HandleFunc("/", handler)
    
    port := ":8080"
    fmt.Printf("Server starting on http://localhost%s\n", port)
    fmt.Printf("OS: %s, Arch: %s\n", runtime.GOOS, runtime.GOARCH)
    
    if err := http.ListenAndServe(port, nil); err != nil {
        log.Fatal(err)
    }
}

// config_dev.go
//go:build dev

package main

const (
    APIEndpoint = "http://localhost:8080"
    Debug       = true
)

// config_prod.go
//go:build prod

package main

const (
    APIEndpoint = "https://api.production.com"
    Debug       = false
)

# 개발 환경 빌드
go build -tags dev -o myapp-dev

# 프로덕션 환경 빌드
go build -tags prod -o myapp-prod

// plugin.go
package main

import "fmt"

func Hello() {
    fmt.Println("Hello from plugin!")
}

// 플러그인 빌드 (Linux/macOS만 지원)
go build -buildmode=plugin -o plugin.so plugin.go

package main

import (
    "fmt"
    "golang.org/x/text/language"
    "golang.org/x/text/message"
)

func main() {
    // 한국어
    p := message.NewPrinter(language.Korean)
    p.Printf("안녕하세요! 숫자: %d\n", 1234567)
    
    // 영어
    p = message.NewPrinter(language.English)
    p.Printf("Hello! Number: %d\n", 1234567)
    
    // 일본어
    p = message.NewPrinter(language.Japanese)
    p.Printf("こんにちは! 数字: %d\n", 1234567)
}

# 기본 최적화
go build -ldflags="-s -w" -o myapp

# 더 공격적인 최적화
go build -ldflags="-s -w" -gcflags="all=-l -B" -o myapp

# 인라이닝 비활성화 (디버깅용)
go build -gcflags="all=-N -l" -o myapp-debug

# UPX 설치 (macOS)
brew install upx

# UPX 설치 (Linux)
apt-get install upx

# 바이너리 압축
upx --best --lzma myapp

# 압축 전후 비교
ls -lh myapp*

#!/bin/bash
# parallel-build.sh

build_platform() {
    local GOOS=$1
    local GOARCH=$2
    local output="myapp-${GOOS}-${GOARCH}"
    
    if [ "$GOOS" = "windows" ]; then
        output="${output}.exe"
    fi
    
    echo "Building for $GOOS/$GOARCH..."
    GOOS=$GOOS GOARCH=$GOARCH go build -ldflags="-s -w" -o "dist/$output" main.go
    echo "✓ Completed $GOOS/$GOARCH"
}

# 병렬 실행
build_platform "windows" "amd64" &
build_platform "darwin" "amd64" &
build_platform "darwin" "arm64" &
build_platform "linux" "amd64" &

# 모든 빌드가 완료될 때까지 대기
wait

echo "All builds completed!"

// 잘못된 방법 ❌
const APIKey = "sk-1234567890abcdef"

// 올바른 방법 ✅
import "os"

apiKey := os.Getenv("API_KEY")
if apiKey == "" {
    log.Fatal("API_KEY environment variable is required")
}

# garble을 사용한 난독화
go install mvdan.cc/garble@latest

garble -literals -tiny build -o myapp-obfuscated main.go

#!/bin/bash
# generate-checksums.sh

cd dist

# SHA256 체크섬 생성
for file in *; do
    if [ -f "$file" ]; then
        sha256sum "$file" >> checksums.txt
    fi
done

echo "Checksums generated in checksums.txt"

myproject/
├── cmd/
│   └── myapp/
│       └── main.go
├── internal/
│   ├── config/
│   ├── handler/
│   └── service/
├── pkg/
│   └── utils/
├── build/
│   ├── build.sh
│   └── Dockerfile
├── dist/
├── .goreleaser.yaml
├── Makefile
├── go.mod
└── go.sum

# .github/workflows/ci-cd.yml

name: CI/CD Pipeline

on:
  push:
    branches: [ main ]
    tags: [ 'v*' ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: '1.21'
      
      - name: Run tests
        run: go test -v -race -coverprofile=coverage.txt ./...
      
      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage.txt

  build:
    needs: test
    runs-on: ubuntu-latest
    if: startsWith(github.ref, 'refs/tags/')
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: '1.21'
      
      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@v4
        with:
          version: latest
          args: release --clean
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  docker:
    needs: test
    runs-on: ubuntu-latest
    if: startsWith(github.ref, 'refs/tags/')
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      
      - name: Login to DockerHub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
      
      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
          tags: |
            myapp:latest
            myapp:${{ github.ref_name }}

# MyApp

## Installation

### Windows
```powershell
# Download the latest release
curl -LO https://github.com/user/myapp/releases/latest/download/myapp-windows-amd64.exe

# Run
.\myapp-windows-amd64.exe
```

### macOS
```bash
# Intel Mac
curl -LO https://github.com/user/myapp/releases/latest/download/myapp-darwin-amd64
chmod +x myapp-darwin-amd64
./myapp-darwin-amd64

# Apple Silicon (M1/M2)
curl -LO https://github.com/user/myapp/releases/latest/download/myapp-darwin-arm64
chmod +x myapp-darwin-arm64
./myapp-darwin-arm64
```

### Linux
```bash
curl -LO https://github.com/user/myapp/releases/latest/download/myapp-linux-amd64
chmod +x myapp-linux-amd64
./myapp-linux-amd64
```

## Docker
```bash
docker run -it myapp:latest
```