Deployment & Production Go

# 1. Hapus Go lama jika ada
sudo rm -rf /usr/local/go

# 2. Download Go terbaru (cek versi di https://go.dev/dl/)
wget https://go.dev/dl/go1.26.0.linux-amd64.tar.gz

# 3. Ekstrak ke /usr/local
sudo tar -C /usr/local -xzf go1.26.0.linux-amd64.tar.gz

# 4. Tambahkan Go ke PATH — edit ~/.bashrc atau ~/.zshrc
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
echo 'export GOPATH=$HOME/go' >> ~/.bashrc
echo 'export PATH=$PATH:$GOPATH/bin' >> ~/.bashrc

# 5. Reload konfigurasi shell
source ~/.bashrc

# 6. Verifikasi
go version
# go version go1.26.0 linux/amd64

sudo apt update
sudo apt install golang-go -y
go version
# Catatan: versi mungkin lebih lama dari upstream

mkdir ~/projects/hello-go && cd ~/projects/hello-go
go mod init hello-go

cat > main.go << 'EOF'
package main

import "fmt"

func main() {
    fmt.Println("Hello dari Go di Linux!")
}
EOF

go run main.go
# Output: Hello dari Go di Linux!

# Build binary executable
go build -o hello-app main.go

# Jalankan binary
./hello-app

# Build untuk platform lain (cross-compile)
GOOS=windows GOARCH=amd64 go build -o hello-app.exe main.go
GOOS=darwin GOARCH=amd64 go build -o hello-app-mac main.go

# Izinkan port aplikasi Go (misal port 8080)
sudo ufw allow 8080/tcp
sudo ufw enable
sudo ufw status

my-go-app/
├── main.go
├── go.mod
├── go.sum
└── Dockerfile

# Base image dengan Go toolchain
FROM golang:1.26-alpine

# Set working directory di dalam container
WORKDIR /app

# Copy dependency files dulu (untuk layer caching)
COPY go.mod go.sum ./
RUN go mod download

# Copy seluruh source code
COPY . .

# Build binary
RUN go build -o my-app main.go

# Expose port yang digunakan aplikasi
EXPOSE 8080

# Perintah yang dijalankan saat container start
CMD ["./my-app"]

# Build Docker image
docker build -t my-go-app:latest .

# Lihat image yang sudah dibuat
docker images

# Jalankan container (port 8080 host → 8080 container)
docker run -d -p 8080:8080 --name go-server my-go-app:latest

# Cek container berjalan
docker ps

# Lihat log container
docker logs -f go-server

# Stop & remove container
docker stop go-server && docker rm go-server

# ── Stage 1: Builder ──
FROM golang:1.26-alpine AS builder

WORKDIR /build

# Install dependencies
COPY go.mod go.sum ./
RUN go mod download

# Copy & build dengan optimasi
COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
    go build \
    -ldflags="-s -w -extldflags=-static" \
    -o app main.go

# ── Stage 2: Final Image ──
# Gunakan scratch (image kosong, 0 byte)
FROM scratch

# Copy hanya binary dari stage builder
COPY --from=builder /build/app /app

# Copy SSL certificates (untuk HTTPS calls)
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/

# Expose port
EXPOSE 8080

# Jalankan binary
ENTRYPOINT ["/app"]

FROM golang:1.26-alpine AS builder
WORKDIR /build
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o app main.go

# Google Distroless: punya user non-root, certs, tzdata
FROM gcr.io/distroless/static:nonroot
COPY --from=builder /build/app /app
EXPOSE 8080
USER nonroot:nonroot
ENTRYPOINT ["/app"]

docker build -t my-go-app:optimized .
docker images | grep my-go-app
# REPOSITORY     TAG         SIZE
# my-go-app      optimized   12.4MB  ← jauh lebih kecil!

version: '3.9'

services:
  # ── Go Application ──
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: go-app
    ports:
      - "8080:8080"
    environment:
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_USER=gouser
      - DB_PASS=secretpass
      - DB_NAME=myapp
      - REDIS_URL=redis:6379
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - app-network
    restart: unless-stopped

  # ── PostgreSQL Database ──
  postgres:
    image: postgres:16-alpine
    container_name: go-postgres
    environment:
      POSTGRES_USER: gouser
      POSTGRES_PASSWORD: secretpass
      POSTGRES_DB: myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U gouser -d myapp"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network

  # ── Redis Cache ──
  redis:
    image: redis:8-alpine
    container_name: go-redis
    volumes:
      - redis_data:/data
    networks:
      - app-network

volumes:
  postgres_data:
  redis_data:

networks:
  app-network:
    driver: bridge

# Jalankan semua service (build jika perlu)
docker compose up -d

# Rebuild & restart hanya service app
docker compose up -d --build app

# Lihat status semua service
docker compose ps

# Lihat log semua service
docker compose logs -f

# Lihat log service spesifik
docker compose logs -f app

# Stop semua service
docker compose down

# Stop + hapus volumes
docker compose down -v

sudo apt install nginx -y
sudo systemctl enable nginx
sudo systemctl start nginx

upstream go_backend {
    server 127.0.0.1:8080;
    # Load balancing ke multiple instances:
    # server 127.0.0.1:8081;
    # server 127.0.0.1:8082;
}

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;

    # Redirect HTTP ke HTTPS
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name yourdomain.com www.yourdomain.com;

    # SSL Certificates (via Certbot)
    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    # Security Headers
    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";
    add_header X-XSS-Protection "1; mode=block";

    # Static files served directly by Nginx
    location /static/ {
        alias /opt/my-go-app/static/;
        expires 30d;
    }

    # Proxy semua request lain ke Go app
    location / {
        proxy_pass http://go_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 86400;
    }
}

# Buat symlink ke sites-enabled
sudo ln -s /etc/nginx/sites-available/my-go-app /etc/nginx/sites-enabled/

# Test konfigurasi Nginx
sudo nginx -t

# Reload Nginx
sudo systemctl reload nginx

# Install SSL via Certbot (free Let's Encrypt)
sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

my-go-app/
├── .github/
│   └── workflows/
│       ├── ci.yml       ← Test & Build (setiap push/PR)
│       └── deploy.yml   ← Deploy ke server (saat merge ke main)
├── main.go
├── main_test.go
└── Dockerfile

name: Go CI

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    name: Test & Build
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v5

    - name: Setup Go
      uses: actions/setup-go@v5
      with:
        go-version: '1.26'
        cache: true

    - name: Download dependencies
      run: go mod download

    - name: Run vet
      run: go vet ./...

    - name: Run tests
      run: go test -v -race -coverprofile=coverage.txt ./...

    - name: Upload coverage
      uses: codecov/codecov-action@v4
      with:
        file: ./coverage.txt

    - name: Build binary
      run: |
        CGO_ENABLED=0 GOOS=linux go build \
          -ldflags="-s -w" \
          -o my-app ./...
      
    - name: Upload artifact
      uses: actions/upload-artifact@v4
      with:
        name: go-binary
        path: my-app

name: Deploy to Production

on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    needs: test  # Hanya deploy jika CI berhasil

    steps:
    - uses: actions/checkout@v5
    - uses: actions/setup-go@v5
      with:
        go-version: '1.26'
    
    - name: Build
      run: CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o my-app .

    - name: Deploy via SSH
      uses: appleboy/ssh-action@v1
      with:
        host: ${{ secrets.SERVER_HOST }}
        username: ${{ secrets.SERVER_USER }}
        key: ${{ secrets.SERVER_SSH_KEY }}
        script: |
          systemctl stop my-go-app
          cp /opt/backup/my-app /opt/backup/my-app.prev
    
    - name: Upload binary
      uses: appleboy/scp-action@v1
      with:
        host: ${{ secrets.SERVER_HOST }}
        username: ${{ secrets.SERVER_USER }}
        key: ${{ secrets.SERVER_SSH_KEY }}
        source: "my-app"
        target: "/opt/my-go-app/"
    
    - name: Restart service
      uses: appleboy/ssh-action@v1
      with:
        host: ${{ secrets.SERVER_HOST }}
        username: ${{ secrets.SERVER_USER }}
        key: ${{ secrets.SERVER_SSH_KEY }}
        script: systemctl start my-go-app