Go

Go (Golang) is a modern, statically typed language designed for simplicity, performance, and scalability. It’s a top choice for DevOps and SRE engineers working with AWS, Azure, GCP, Kubernetes, and cloud-native tooling.

Why DevOps & SREs Should Learn Go

Cloud Native: Go powers Kubernetes, Docker, Prometheus, and many cloud SDKs (AWS, Azure, GCP).
Performance: Compiled binaries, fast startup, and low memory usage make Go ideal for microservices and CLI tools.
Concurrency: Goroutines and channels enable efficient parallel processing for automation and monitoring.
DevOps Ecosystem: Many DevOps tools (Terraform, Helm, Vault, etc.) are written in Go, making it easy to extend or contribute.
Cross-Platform: Build for Linux, NixOS, WSL, and all major clouds with a single codebase.

Real-Life DevOps & SRE Examples

1. Build & Deploy a Go App on Kubernetes

Dockerfile:

FROM golang:1.21-alpine as builder
WORKDIR /app
COPY . .
RUN go build -o app

FROM alpine:3.18
WORKDIR /app
COPY --from=builder /app/app .
CMD ["./app"]

deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myrepo/myapp:v1
        ports:
        - containerPort: 8080

2. Kubernetes Operator with Go (kubebuilder)

// ...existing code for imports...
func (r *MyResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    // Custom reconciliation logic
    // ...
    return ctrl.Result{}, nil
}

3. Custom Kubernetes Controller

// ...existing code for imports...
func main() {
    // Setup manager, scheme, and controller
    // Watch for resource changes and automate tasks
    // ...
}

4. Prometheus Exporter in Go

package main
import (
    "net/http"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)
func main() {
    myMetric := prometheus.NewGauge(prometheus.GaugeOpts{
        Name: "my_custom_metric",
        Help: "A custom metric for SREs",
    })
    prometheus.MustRegister(myMetric)
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":2112", nil)
}

5. CI/CD Pipeline Step (GitHub Actions)

- name: Build Go binary
  run: go build -o app
- name: Run tests
  run: go test ./...

Best Practices (2025)

Use Go modules for dependency management
Write unit and integration tests (use testing and testify)
Lint and format code with golangci-lint and gofmt
Use context for cancellation/timeouts in automation
Pin dependencies in go.mod
Document code and APIs

Common Pitfalls

Not handling errors (always check returned errors)
Hardcoding credentials (use env vars or secret managers)
Ignoring context cancellation in long-running tasks
Not using modules (avoid GOPATH for new projects)

References

Go Joke: Why did the SRE love Go? Because handling errors is a feature, not a bug!