گولنگ برای مهندسان DevOps - چرا Go زبان اول زیرساخت است

# کامپایل برای لینوکس
GOOS=linux GOARCH=amd64 go build -o mytool

# این فایل روی هر سرور لینوکسی کار می‌کند
# بدون نیاز به نصب runtime، pip، npm یا هر چیز دیگری
scp mytool server:/usr/local/bin/

# از macOS برای تمام پلتفرم‌ها build کنید
GOOS=linux   GOARCH=amd64 go build -o mytool-linux
GOOS=darwin  GOARCH=arm64 go build -o mytool-mac
GOOS=windows GOARCH=amd64 go build -o mytool.exe

// بررسی همزمان وضعیت ۱۰۰ سرور
func checkServers(servers []string) []Result {
    results := make(chan Result, len(servers))

    for _, server := range servers {
        go func(s string) {
            status := ping(s)
            results <- Result{Server: s, Status: status}
        }(server)
    }

    var all []Result
    for range servers {
        all = append(all, <-results)
    }
    return all
}

// یک CLI ساده برای مدیریت deployment
package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Usage: deploy <environment>")
        os.Exit(1)
    }

    env := os.Args[1]

    // اعتبارسنجی محیط
    validEnvs := map[string]bool{"staging": true, "production": true}
    if !validEnvs[env] {
        fmt.Printf("Invalid environment: %s\n", env)
        os.Exit(1)
    }

    // اجرای kubectl
    cmd := exec.Command("kubectl", "apply", "-f",
        fmt.Sprintf("k8s/%s/", env))
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        fmt.Printf("Deployment failed: %v\n", err)
        os.Exit(1)
    }

    fmt.Printf("Successfully deployed to %s\n", env)
}

// بررسی سلامت سرویس‌ها و ارسال هشدار
package main

import (
    "fmt"
    "net/http"
    "time"
)

type Service struct {
    Name string
    URL  string
}

func checkHealth(svc Service) error {
    client := &http.Client{Timeout: 5 * time.Second}
    resp, err := client.Get(svc.URL)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("status %d", resp.StatusCode)
    }
    return nil
}

func main() {
    services := []Service{
        {Name: "API Gateway", URL: "https://api.example.com/health"},
        {Name: "Auth Service", URL: "https://auth.example.com/health"},
        {Name: "User Service", URL: "https://users.example.com/health"},
    }

    for _, svc := range services {
        if err := checkHealth(svc); err != nil {
            fmt.Printf("[FAIL] %s: %v\n", svc.Name, err)
            // اینجا می‌توانید به Slack/PagerDuty هشدار بفرستید
        } else {
            fmt.Printf("[OK] %s\n", svc.Name)
        }
    }
}

// kubectl-pods-by-node: نمایش pods به تفکیک node
package main

import (
    "context"
    "fmt"
    "os"
    "path/filepath"

    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
)

func main() {
    // خواندن kubeconfig
    home, _ := os.UserHomeDir()
    kubeconfig := filepath.Join(home, ".kube", "config")

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }

    // گرفتن لیست pods
    pods, err := clientset.CoreV1().Pods("").List(
        context.Background(),
        metav1.ListOptions{},
    )
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }

    // گروه‌بندی بر اساس node
    byNode := make(map[string][]string)
    for _, pod := range pods.Items {
        byNode[pod.Spec.NodeName] = append(
            byNode[pod.Spec.NodeName],
            pod.Name,
        )
    }

    // نمایش نتایج
    for node, podList := range byNode {
        fmt.Printf("\n=== %s (%d pods) ===\n", node, len(podList))
        for _, p := range podList {
            fmt.Printf("  - %s\n", p)
        }
    }
}

// exporter برای متریک‌های سفارشی اپلیکیشن
package main

import (
    "net/http"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    requestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "myapp_requests_total",
            Help: "Total number of requests",
        },
        []string{"method", "endpoint", "status"},
    )

    requestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "myapp_request_duration_seconds",
            Help:    "Request duration in seconds",
            Buckets: prometheus.DefBuckets,
        },
        []string{"method", "endpoint"},
    )
)

func init() {
    prometheus.MustRegister(requestsTotal)
    prometheus.MustRegister(requestDuration)
}

func main() {
    // endpoint برای Prometheus
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":9090", nil)
}

// دریافت webhook از GitHub و اجرای عملیات
package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "os/exec"
)

type PushEvent struct {
    Ref        string `json:"ref"`
    Repository struct {
        Name     string `json:"name"`
        CloneURL string `json:"clone_url"`
    } `json:"repository"`
}

func verifySignature(payload []byte, signature string, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(payload)
    expected := "sha256=" + hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(expected), []byte(signature))
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    payload, _ := io.ReadAll(r.Body)

    // اعتبارسنجی signature
    signature := r.Header.Get("X-Hub-Signature-256")
    if !verifySignature(payload, signature, os.Getenv("WEBHOOK_SECRET")) {
        http.Error(w, "Invalid signature", http.StatusUnauthorized)
        return
    }

    var event PushEvent
    json.Unmarshal(payload, &event)

    // فقط برای main branch
    if event.Ref == "refs/heads/main" {
        go func() {
            cmd := exec.Command("./deploy.sh", event.Repository.Name)
            cmd.Run()
        }()
    }

    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "OK")
}

func main() {
    http.HandleFunc("/webhook", webhookHandler)
    http.ListenAndServe(":8080", nil)
}