#Go for DevOps

1# Ubuntu/Debian
2sudo apt update
3sudo apt install golang-go
4
5# Or download from golang.org
6wget https://go.dev/dl/go1.21.0.linux-amd64.tar.gz
7sudo tar -C /usr/local -xzf go1.21.0.linux-amd64.tar.gz
8export PATH=$PATH:/usr/local/go/bin
9
10# macOS (Homebrew)
11brew install go
12
13# Windows (Chocolatey)
14choco install golang
15
16# Verify installation
17go version

1package main
2
3import "fmt"
4
5func main() {
6    fmt.Println("Hello, DevOps!")
7}

1# Run directly
2go run main.go
3
4# Build binary
5go build -o myapp main.go
6./myapp

1package main
2
3import "fmt"
4
5func main() {
6    // Variable declarations
7    var serverName string = "web-server-01"
8    var port int = 8080
9    var isHealthy bool = true
10    
11    // Short declaration
12    region := "us-east-1"
13    cpuUsage := 75.5
14    
15    // Arrays and slices
16    servers := []string{"web-01", "web-02", "web-03"}
17    
18    // Maps (dictionaries)
19    serverConfig := map[string]interface{}{
20        "name": "web-server-01",
21        "port": 8080,
22        "enabled": true,
23    }
24    
25    fmt.Printf("Server: %s, Port: %d\n", serverName, port)
26    fmt.Printf("Region: %s, Healthy: %v\n", region, isHealthy)
27    fmt.Printf("CPU Usage: %.1f%%\n", cpuUsage)
28    fmt.Printf("Servers: %v\n", servers)
29    fmt.Printf("Config: %v\n", serverConfig)
30}

1package main
2
3import "fmt"
4
5// Server represents a server in our infrastructure
6type Server struct {
7    Name        string
8    IP          string
9    Port        int
10    Environment string
11    IsHealthy   bool
12}
13
14// Method on Server struct
15func (s *Server) CheckHealth() bool {
16    // Health check implementation
17    fmt.Printf("Checking health of %s...\n", s.Name)
18    return s.IsHealthy
19}
20
21func (s *Server) Restart() error {
22    fmt.Printf("Restarting %s...\n", s.Name)
23    // Restart implementation
24    return nil
25}
26
27func main() {
28    server := Server{
29        Name:        "web-01",
30        IP:          "10.0.1.100",
31        Port:        8080,
32        Environment: "production",
33        IsHealthy:   true,
34    }
35    
36    if server.CheckHealth() {
37        fmt.Println("Server is healthy!")
38    }
39}

1package main
2
3import (
4    "errors"
5    "fmt"
6    "os"
7)
8
9func readConfig(path string) ([]byte, error) {
10    data, err := os.ReadFile(path)
11    if err != nil {
12        return nil, fmt.Errorf("failed to read config: %w", err)
13    }
14    return data, nil
15}
16
17func main() {
18    data, err := readConfig("/etc/myapp/config.yaml")
19    if err != nil {
20        fmt.Printf("Error: %v\n", err)
21        os.Exit(1)
22    }
23    fmt.Printf("Config loaded: %d bytes\n", len(data))
24}
25
26// Custom errors
27var ErrServerNotFound = errors.New("server not found")
28
29func getServer(name string) (*Server, error) {
30    // ...
31    return nil, ErrServerNotFound
32}

go get -u github.com/spf13/cobra@latest

1// cmd/root.go
2package cmd
3
4import (
5    "fmt"
6    "os"
7    
8    "github.com/spf13/cobra"
9)
10
11var rootCmd = &cobra.Command{
12    Use:   "devops-cli",
13    Short: "A DevOps CLI tool",
14    Long:  `A comprehensive CLI tool for DevOps automation.`,
15}
16
17func Execute() {
18    if err := rootCmd.Execute(); err != nil {
19        fmt.Println(err)
20        os.Exit(1)
21    }
22}
23
24func init() {
25    rootCmd.PersistentFlags().StringP("config", "c", "", "config file path")
26}

1// cmd/server.go
2package cmd
3
4import (
5    "fmt"
6    
7    "github.com/spf13/cobra"
8)
9
10var serverCmd = &cobra.Command{
11    Use:   "server",
12    Short: "Server management commands",
13}
14
15var serverListCmd = &cobra.Command{
16    Use:   "list",
17    Short: "List all servers",
18    Run: func(cmd *cobra.Command, args []string) {
19        env, _ := cmd.Flags().GetString("environment")
20        fmt.Printf("Listing servers for environment: %s\n", env)
21        // List servers implementation
22    },
23}
24
25var serverHealthCmd = &cobra.Command{
26    Use:   "health [server-name]",
27    Short: "Check server health",
28    Args:  cobra.ExactArgs(1),
29    Run: func(cmd *cobra.Command, args []string) {
30        serverName := args[0]
31        fmt.Printf("Checking health of %s...\n", serverName)
32        // Health check implementation
33    },
34}
35
36func init() {
37    rootCmd.AddCommand(serverCmd)
38    serverCmd.AddCommand(serverListCmd)
39    serverCmd.AddCommand(serverHealthCmd)
40    
41    serverListCmd.Flags().StringP("environment", "e", "all", "Environment filter")
42}

1// main.go
2package main
3
4import "github.com/username/devops-cli/cmd"
5
6func main() {
7    cmd.Execute()
8}

1# Build the CLI
2go build -o devops-cli .
3
4# Use the CLI
5./devops-cli server list -e production
6./devops-cli server health web-01

1package main
2
3import (
4    "encoding/json"
5    "fmt"
6    "io"
7    "net/http"
8    "time"
9)
10
11type GitHubUser struct {
12    Login     string `json:"login"`
13    Name      string `json:"name"`
14    PublicRepos int  `json:"public_repos"`
15}
16
17func main() {
18    // Create HTTP client with timeout
19    client := &http.Client{
20        Timeout: 10 * time.Second,
21    }
22    
23    // Make GET request
24    resp, err := client.Get("https://api.github.com/users/octocat")
25    if err != nil {
26        fmt.Printf("Error: %v\n", err)
27        return
28    }
29    defer resp.Body.Close()
30    
31    // Read response body
32    body, err := io.ReadAll(resp.Body)
33    if err != nil {
34        fmt.Printf("Error reading body: %v\n", err)
35        return
36    }
37    
38    // Parse JSON
39    var user GitHubUser
40    if err := json.Unmarshal(body, &user); err != nil {
41        fmt.Printf("Error parsing JSON: %v\n", err)
42        return
43    }
44    
45    fmt.Printf("User: %s\n", user.Name)
46    fmt.Printf("Repos: %d\n", user.PublicRepos)
47}

1package main
2
3import (
4    "encoding/json"
5    "log"
6    "net/http"
7)
8
9type HealthResponse struct {
10    Status    string `json:"status"`
11    Version   string `json:"version"`
12    Uptime    string `json:"uptime"`
13}
14
15func healthHandler(w http.ResponseWriter, r *http.Request) {
16    response := HealthResponse{
17        Status:  "healthy",
18        Version: "1.0.0",
19        Uptime:  "24h",
20    }
21    
22    w.Header().Set("Content-Type", "application/json")
23    json.NewEncoder(w).Encode(response)
24}
25
26func main() {
27    http.HandleFunc("/health", healthHandler)
28    
29    log.Println("Server starting on :8080")
30    if err := http.ListenAndServe(":8080", nil); err != nil {
31        log.Fatal(err)
32    }
33}

1package main
2
3import (
4    "fmt"
5    "net"
6    "sync"
7    "time"
8)
9
10func checkServer(name string, host string, port int, wg *sync.WaitGroup) {
11    defer wg.Done()
12    
13    address := fmt.Sprintf("%s:%d", host, port)
14    conn, err := net.DialTimeout("tcp", address, 5*time.Second)
15    
16    if err != nil {
17        fmt.Printf("❌ %s: unhealthy (%v)\n", name, err)
18        return
19    }
20    defer conn.Close()
21    
22    fmt.Printf("✅ %s: healthy\n", name)
23}
24
25func main() {
26    servers := []struct {
27        name string
28        host string
29        port int
30    }{
31        {"Google", "google.com", 443},
32        {"GitHub", "github.com", 443},
33        {"Localhost", "localhost", 8080},
34    }
35    
36    var wg sync.WaitGroup
37    
38    fmt.Println("🔍 Checking servers...")
39    
40    for _, server := range servers {
41        wg.Add(1)
42        go checkServer(server.name, server.host, server.port, &wg)
43    }
44    
45    wg.Wait()
46    fmt.Println("✨ All checks complete!")
47}

1package main
2
3import (
4    "fmt"
5    "time"
6)
7
8type HealthResult struct {
9    Server  string
10    Healthy bool
11    Latency time.Duration
12}
13
14func checkHealth(server string, results chan<- HealthResult) {
15    start := time.Now()
16    // Simulate health check
17    time.Sleep(100 * time.Millisecond)
18    
19    results <- HealthResult{
20        Server:  server,
21        Healthy: true,
22        Latency: time.Since(start),
23    }
24}
25
26func main() {
27    servers := []string{"web-01", "web-02", "api-01", "db-01"}
28    results := make(chan HealthResult, len(servers))
29    
30    // Start health checks concurrently
31    for _, server := range servers {
32        go checkHealth(server, results)
33    }
34    
35    // Collect results
36    for i := 0; i < len(servers); i++ {
37        result := <-results
38        status := "✅"
39        if !result.Healthy {
40            status = "❌"
41        }
42        fmt.Printf("%s %s (latency: %v)\n", status, result.Server, result.Latency)
43    }
44}

1# Build for Linux (from any OS)
2GOOS=linux GOARCH=amd64 go build -o myapp-linux
3
4# Build for macOS
5GOOS=darwin GOARCH=amd64 go build -o myapp-mac
6
7# Build for Windows
8GOOS=windows GOARCH=amd64 go build -o myapp.exe
9
10# Build for ARM (Raspberry Pi)
11GOOS=linux GOARCH=arm64 go build -o myapp-arm