Deployment

Advanced Build Optimization

Create optimized, secure, and multi-architecture Go binaries with advanced build techniques.

# Build for current platform
go build -o myapp main.go

# Build with optimizations (strip debug info)
go build -ldflags="-s -w" -o myapp main.go

# Cross-compilation for Linux
GOOS=linux GOARCH=amd64 go build -o myapp-linux main.go

# Cross-compilation for Windows
GOOS=windows GOARCH=amd64 go build -o myapp.exe main.go

# Cross-compilation for macOS
GOOS=darwin GOARCH=amd64 go build -o myapp-mac main.go

# Build with version information
go build -ldflags="-X main.Version=1.0.0" -o myapp main.go

Production Docker Strategies

Build secure, efficient Docker images with multi-stage builds, distroless bases, and security scanning.

# Dockerfile for Go application
# Build stage
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 -installsuffix cgo -o main .

# Final stage
FROM alpine:latest

RUN apk --no-cache add ca-certificates
WORKDIR /root/

COPY --from=builder /app/main .
COPY --from=builder /app/config.yml .

EXPOSE 8080
CMD ["./main"]

# Docker commands
# Build image
docker build -t myapp:latest .

# Run container
docker run -d -p 8080:8080 --name myapp myapp:latest

# Push to registry
docker tag myapp:latest registry.example.com/myapp:latest
docker push registry.example.com/myapp:latest

️ Enterprise Kubernetes

Deploy production-ready applications with advanced Kubernetes patterns including operators, service mesh, and GitOps.

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-app
  labels:
    app: go-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: go-app
  template:
    metadata:
      labels:
        app: go-app
    spec:
      containers:
      - name: go-app
        image: registry.example.com/go-app:latest
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: go-app-service
spec:
  selector:
    app: go-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

# Deploy to Kubernetes
kubectl apply -f deployment.yaml

# Check deployment status
kubectl get deployments
kubectl get pods
kubectl get services

# Scale deployment
kubectl scale deployment go-app --replicas=5

# Update image
kubectl set image deployment/go-app go-app=registry.example.com/go-app:v2

Advanced CI/CD Pipelines

Build sophisticated CI/CD pipelines with security scanning, multi-environment deployments, and automated rollbacks.

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [ main ]
  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: Test
      run: |
        go test -v ./...
        go test -race -coverprofile=coverage.txt -covermode=atomic ./...
    
    - name: Upload coverage
      uses: codecov/codecov-action@v3

  build-and-push:
    needs: test
    runs-on: ubuntu-latest
    if: github.event_name == 'push'
    
    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.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}
    
    - name: Build and push
      uses: docker/build-push-action@v4
      with:
        push: true
        tags: |
          myapp:latest
          myapp:${{ github.sha }}
        
  deploy:
    needs: build-and-push
    runs-on: ubuntu-latest
    
    steps:
    - name: Deploy to Kubernetes
      uses: azure/k8s-deploy@v4
      with:
        manifests: |
          deployment.yaml
        images: |
          myapp:${{ github.sha }}

️ Configuration Management

Implement enterprise configuration management with secrets, service mesh config, and GitOps patterns.

package main

import (
    "os"
    "github.com/spf13/viper"
)

type Config struct {
    Server   ServerConfig
    Database DatabaseConfig
    Redis    RedisConfig
    App      AppConfig
}

type ServerConfig struct {
    Port     string `mapstructure:"port"`
    Host     string `mapstructure:"host"`
    Timeout  int    `mapstructure:"timeout"`
}

type DatabaseConfig struct {
    Host     string `mapstructure:"host"`
    Port     int    `mapstructure:"port"`
    User     string `mapstructure:"user"`
    Password string `mapstructure:"password"`
    DBName   string `mapstructure:"dbname"`
}

func LoadConfig() (*Config, error) {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")
    viper.AddConfigPath("./config")
    
    // Environment variables override
    viper.SetEnvPrefix("APP")
    viper.AutomaticEnv()
    
    // Set defaults
    viper.SetDefault("server.port", "8080")
    viper.SetDefault("server.timeout", 30)
    
    // Load config file for environment
    env := os.Getenv("APP_ENV")
    if env != "" {
        viper.SetConfigName("config." + env)
    }
    
    if err := viper.ReadInConfig(); err != nil {
        return nil, err
    }
    
    var config Config
    if err := viper.Unmarshal(&config); err != nil {
        return nil, err
    }
    
    return &config, nil
}

️ System Service Management

Deploy applications as robust system services with proper isolation, monitoring, and security hardening.

# /etc/systemd/system/myapp.service
[Unit]
Description=My Go Application
After=network.target

[Service]
Type=simple
User=appuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/myapp
Restart=on-failure
RestartSec=10
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=myapp
Environment="APP_ENV=production"

[Install]
WantedBy=multi-user.target

# Service management commands
# Copy binary
sudo cp myapp /opt/myapp/

# Create service file
sudo cp myapp.service /etc/systemd/system/

# Reload systemd
sudo systemctl daemon-reload

# Start service
sudo systemctl start myapp

# Enable auto-start
sudo systemctl enable myapp

# Check status
sudo systemctl status myapp

# View logs
sudo journalctl -u myapp -f

Production Observability

Build comprehensive observability with SLO monitoring, distributed tracing, and intelligent alerting.

package main

import (
    "encoding/json"
    "net/http"
    "time"
)

type HealthStatus struct {
    Status    string            `json:"status"`
    Timestamp time.Time         `json:"timestamp"`
    Checks    map[string]string `json:"checks"`
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    status := HealthStatus{
        Status:    "healthy",
        Timestamp: time.Now(),
        Checks:    make(map[string]string),
    }
    
    // Check database
    if err := checkDatabase(); err != nil {
        status.Status = "unhealthy"
        status.Checks["database"] = "failed: " + err.Error()
    } else {
        status.Checks["database"] = "ok"
    }
    
    // Check Redis
    if err := checkRedis(); err != nil {
        status.Status = "unhealthy"
        status.Checks["redis"] = "failed: " + err.Error()
    } else {
        status.Checks["redis"] = "ok"
    }
    
    // Set response status
    if status.Status == "unhealthy" {
        w.WriteHeader(http.StatusServiceUnavailable)
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(status)
}

func metricsHandler(w http.ResponseWriter, r *http.Request) {
    // Prometheus metrics endpoint
    metrics := `
# HELP http_requests_total Total HTTP requests
# TYPE http_requests_total counter
http_requests_total{method="GET",status="200"} 1234
http_requests_total{method="POST",status="201"} 567

# HELP response_time_seconds Response time in seconds
# TYPE response_time_seconds histogram
response_time_seconds_bucket{le="0.1"} 1000
response_time_seconds_bucket{le="0.5"} 1200
response_time_seconds_bucket{le="1.0"} 1234
`
    w.Header().Set("Content-Type", "text/plain")
    w.Write([]byte(metrics))
}

Graceful Lifecycle Management

Implement comprehensive lifecycle management with graceful startup, shutdown, and zero-downtime deployments.

package main

import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    srv := &http.Server{
        Addr:    ":8080",
        Handler: setupRoutes(),
    }
    
    // Start server in goroutine
    go func() {
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server failed: %v", err)
        }
    }()
    
    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    log.Println("Shutting down server...")
    
    // Graceful shutdown with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatal("Server forced to shutdown:", err)
    }
    
    log.Println("Server exited")
}

// ArgoCD Application Manifest
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: go-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/company/go-app-config
    targetRevision: HEAD
    path: k8s
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

// Terraform for Immutable Infrastructure
resource "aws_launch_template" "app" {
  name_prefix   = "go-app-"
  image_id      = var.ami_id
  instance_type = "t3.medium"
  
  vpc_security_group_ids = [aws_security_group.app.id]
  
  user_data = base64encode(templatefile("userdata.sh", {
    app_version = var.app_version
    config_s3_bucket = aws_s3_bucket.config.bucket
  }))
  
  lifecycle {
    create_before_destroy = true
  }
}

// Flagger Canary Deployment
apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
  name: go-app
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: go-app
  service:
    port: 8080
  analysis:
    interval: 1m
    threshold: 5
    maxWeight: 50
    stepWeight: 10
    metrics:
    - name: request-success-rate
      thresholdRange:
        min: 99
    - name: request-duration
      thresholdRange:
        max: 500

# Security Pipeline Stage
security_scan:
  stage: security
  image: aquasec/trivy:latest
  script:
    - trivy image --exit-code 1 --severity HIGH,CRITICAL $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
    - govulncheck ./...
    - gosec -fmt sarif -out gosec.sarif ./...
  artifacts:
    reports:
      sast: gosec.sarif
  only:
    - main

// Multi-Cloud Terraform Configuration
package main

import (
    "context"
    "log"
    "os"
    
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/ecs"
    "cloud.google.com/go/run/apiv2/runpb"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
)

type MultiCloudDeployer struct {
    awsClient   *ecs.Client
    gcpClient   *run.ServicesClient
    azureClient *containerinstance.ContainerGroupsClient
    config      *DeploymentConfig
}

type DeploymentConfig struct {
    ImageURI        string            `yaml:"imageUri"`
    Environments    []Environment     `yaml:"environments"`
    HealthCheckURL  string            `yaml:"healthCheckUrl"`
    Resources       ResourceLimits    `yaml:"resources"`
    Scaling         ScalingPolicy     `yaml:"scaling"`
}

type Environment struct {
    Name     string            `yaml:"name"`
    Provider string            `yaml:"provider"` // aws, gcp, azure
    Region   string            `yaml:"region"`
    Config   map[string]string `yaml:"config"`
}

func (d *MultiCloudDeployer) Deploy(ctx context.Context) error {
    for _, env := range d.config.Environments {
        switch env.Provider {
        case "aws":
            if err := d.deployToAWS(ctx, env); err != nil {
                return fmt.Errorf("AWS deployment failed: %w", err)
            }
        case "gcp":
            if err := d.deployToGCP(ctx, env); err != nil {
                return fmt.Errorf("GCP deployment failed: %w", err)
            }
        case "azure":
            if err := d.deployToAzure(ctx, env); err != nil {
                return fmt.Errorf("Azure deployment failed: %w", err)
            }
        }
        
        // Verify deployment health
        if err := d.verifyDeployment(ctx, env); err != nil {
            // Trigger rollback
            d.rollback(ctx, env)
            return fmt.Errorf("deployment verification failed: %w", err)
        }
    }
    
    return nil
}

func (d *MultiCloudDeployer) deployToAWS(ctx context.Context, env Environment) error {
    // ECS Fargate deployment
    taskDef := &ecs.RegisterTaskDefinitionInput{
        Family:      aws.String("go-app"),
        NetworkMode: types.NetworkModeAwsvpc,
        RequiresCompatibilities: []types.Compatibility{
            types.CompatibilityFargate,
        },
        Cpu:    aws.String("256"),
        Memory: aws.String("512"),
        ContainerDefinitions: []types.ContainerDefinition{
            {
                Name:  aws.String("go-app"),
                Image: aws.String(d.config.ImageURI),
                PortMappings: []types.PortMapping{
                    {
                        ContainerPort: aws.Int32(8080),
                        Protocol:      types.TransportProtocolTcp,
                    },
                },
                Environment: d.buildEnvironmentVariables(env),
                HealthCheck: &types.HealthCheck{
                    Command: []string{
                        "CMD-SHELL",
                        fmt.Sprintf("curl -f %s || exit 1", d.config.HealthCheckURL),
                    },
                    Interval:    aws.Int32(30),
                    Timeout:     aws.Int32(5),
                    Retries:     aws.Int32(3),
                    StartPeriod: aws.Int32(60),
                },
            },
        },
    }
    
    _, err := d.awsClient.RegisterTaskDefinition(ctx, taskDef)
    return err
}

// Zero-Downtime Deployment with Health Checks
type ZeroDowntimeDeployer struct {
    oldVersion    string
    newVersion    string
    healthChecker HealthChecker
    loadBalancer  LoadBalancer
}

func (z *ZeroDowntimeDeployer) Deploy(ctx context.Context) error {
    // Phase 1: Deploy new version alongside old
    if err := z.deployNewVersion(ctx); err != nil {
        return fmt.Errorf("new version deployment failed: %w", err)
    }
    
    // Phase 2: Wait for new version to be healthy
    if err := z.waitForHealth(ctx, z.newVersion); err != nil {
        z.cleanup(ctx, z.newVersion)
        return fmt.Errorf("new version health check failed: %w", err)
    }
    
    // Phase 3: Gradually shift traffic
    trafficSplits := []int{10, 25, 50, 75, 100}
    for _, split := range trafficSplits {
        if err := z.loadBalancer.UpdateTrafficSplit(ctx, z.newVersion, split); err != nil {
            z.rollback(ctx)
            return fmt.Errorf("traffic split to %d%% failed: %w", split, err)
        }
        
        // Monitor metrics during traffic split
        if err := z.monitorMetrics(ctx, 2*time.Minute); err != nil {
            z.rollback(ctx)
            return fmt.Errorf("metrics degraded during %d%% traffic: %w", split, err)
        }
    }
    
    // Phase 4: Remove old version
    if err := z.cleanup(ctx, z.oldVersion); err != nil {
        log.Printf("Warning: failed to cleanup old version %s: %v", z.oldVersion, err)
    }
    
    return nil
}