Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: CLIs mit flag und cobra – kctxsafe

Ziel: Ein CLI bauen, das kubeconfig-Kontexte anzeigt und den Wechsel nach prod nur mit Bestätigung erlaubt · Dauer: ca. 120 min · Voraussetzung: Tag 4

Briefing

  • kctxsafe list|current|use – ein Sicherheitsgurt um kubectl config.
  • Erst flag aus der Standardbibliothek, dann Umbau auf cobra mit Unterbefehlen.
  • Konfiguration in fester Reihenfolge: Default < Datei < Env < Flag.
  • os/exec ruft kubectl auf – immer mit expliziter --kubeconfig, nie die Default-Datei.
  • Tests ersetzen kubectl durch eine Funktion: kein Cluster, keine echte Kubeconfig.
kctxsafe use prod-eu
   |-- setup: --kubeconfig/$KUBECONFIG, Config-Datei, $KCTXSAFE_PROD_PATTERN
   |-- prod? --> Namen tippen lassen --> falsch: Abbruch, Exit 1
   '-- kubectl config use-context prod-eu --kubeconfig <datei>

Sicherheit: In diesem Kapitel arbeitest du ausschließlich mit lab-kubeconfig.yaml im Lab-Ordner. Deine echte ~/.kube/config bleibt unberührt – kctxsafe hat absichtlich keinen Fallback darauf.

Drill 1: Modul und Lab-Kubeconfig

mkdir -p ~/go-lab/tag05-kctxsafe && cd ~/go-lab/tag05-kctxsafe
go mod init example.com/kctxsafe
mkdir -p cmd/kctxsafe internal/kube internal/config internal/guard

Erwartet:

go: creating new go.mod: module example.com/kctxsafe

Die Lab-Kubeconfig enthält drei erfundene Cluster. Die Server existieren nicht – kubectl config liest und schreibt nur die Datei.

cat > lab-kubeconfig.yaml <<'EOF'
apiVersion: v1
clusters:
- cluster:
    server: https://127.0.0.1:6443
  name: dev
- cluster:
    server: https://127.0.0.1:6445
  name: prod
- cluster:
    server: https://127.0.0.1:6444
  name: staging
contexts:
- context:
    cluster: dev
    namespace: default
    user: lab
  name: kind-dev
- context:
    cluster: prod
    user: lab
  name: prod-eu
- context:
    cluster: staging
    user: lab
  name: staging
current-context: kind-dev
kind: Config
users:
- name: lab
  user:
    token: lab-token-1234
EOF
export KUBECONFIG=$PWD/lab-kubeconfig.yaml   # nur in dieser Shell
kubectl config get-contexts -o name
kubectl config current-context

Erwartet:

kind-dev
prod-eu
staging
kind-dev

Achtung: Öffne für dieses Kapitel eine eigene Terminal-Session. So kann ein vergessenes export KUBECONFIG keine andere Shell treffen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: kubectl per os/exec

kube.Client kapselt genau eine Kubeconfig-Datei. Der Runner ist ein Funktionstyp – in Produktion os/exec, im Test eine Attrappe.

cat > internal/kube/kube.go <<'EOF'
// Package kube ruft kubectl auf – immer mit expliziter --kubeconfig.
package kube

import (
    "context"
    "errors"
    "fmt"
    "os"
    "os/exec"
    "strings"
)

// Runner führt ein Programm aus und liefert stdout. In Tests ersetzt du ihn.
type Runner func(ctx context.Context, name string, args ...string) ([]byte, error)

// ExecRunner startet das echte Programm per os/exec.
func ExecRunner(ctx context.Context, name string, args ...string) ([]byte, error) {
    out, err := exec.CommandContext(ctx, name, args...).Output()
    var ee *exec.ExitError
    if errors.As(err, &ee) {
        return nil, fmt.Errorf("%s: %s", name, strings.TrimSpace(string(ee.Stderr)))
    }
    return out, err
}

// Client kapselt kubectl config für genau eine Kubeconfig-Datei.
type Client struct {
    Kubeconfig string
    Run        Runner
}

func (c Client) config(ctx context.Context, args ...string) (string, error) {
    if c.Kubeconfig == "" {
        return "", errors.New("keine Kubeconfig angegeben")
    }
    if _, err := os.Stat(c.Kubeconfig); err != nil {
        return "", err
    }
    args = append([]string{"config"}, args...)
    args = append(args, "--kubeconfig", c.Kubeconfig)
    out, err := c.Run(ctx, "kubectl", args...)
    return strings.TrimSpace(string(out)), err
}

// Contexts listet alle Kontextnamen.
func (c Client) Contexts(ctx context.Context) ([]string, error) {
    out, err := c.config(ctx, "get-contexts", "-o", "name")
    if err != nil {
        return nil, err
    }
    return strings.Fields(out), nil
}

// Current liefert den aktiven Kontext.
func (c Client) Current(ctx context.Context) (string, error) {
    return c.config(ctx, "current-context")
}

// Use setzt den aktiven Kontext.
func (c Client) Use(ctx context.Context, name string) error {
    _, err := c.config(ctx, "use-context", name)
    return err
}
EOF

Warum? cmd.Output() legt stderr bei Exit-Code ≠ 0 in *exec.ExitError ab; mit errors.As (Tag 3) holst du kubectls eigene Fehlermeldung heraus. CommandContext beendet kubectl, wenn der Context abläuft oder du Strg+C drückst.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Erster Wurf mit flag

Das Paket flag reicht für ein Tool mit einer Aufgabe. Der Default kommt aus der Umgebung.

cat > cmd/kctxsafe/main.go <<'EOF'
package main

import (
    "context"
    "flag"
    "fmt"
    "os"

    "example.com/kctxsafe/internal/kube"
)

func main() {
    kubeconfig := flag.String("kubeconfig", os.Getenv("KUBECONFIG"),
        "Kubeconfig-Datei")
    flag.Parse()

    c := kube.Client{Kubeconfig: *kubeconfig, Run: kube.ExecRunner}
    cur, err := c.Current(context.Background())
    if err != nil {
        fmt.Fprintln(os.Stderr, "kctxsafe:", err)
        os.Exit(1)
    }
    fmt.Println(cur)
}
EOF
go run ./cmd/kctxsafe
go run ./cmd/kctxsafe -kubeconfig fehlt.yaml
KUBECONFIG= go run ./cmd/kctxsafe
go run ./cmd/kctxsafe -h

Erwartet (gekürzt):

kind-dev
kctxsafe: stat fehlt.yaml: no such file or directory
exit status 1
kctxsafe: keine Kubeconfig angegeben
exit status 1
Usage of /Users/.../go-build/.../kctxsafe:
  -kubeconfig string
        Kubeconfig-Datei (default "/Users/.../tag05-kctxsafe/lab-kubeconfig.yaml")

Warum? flag kennt nur ein Kommando und einfache Typen. Für list, current und use mit eigenen Flags und Hilfe pro Befehl lohnt sich cobra – das Framework hinter kubectl, helm und gh.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Config aus Datei und Env

Eine key=value-Datei parst du mit dem Wissen aus Tag 1 – kein Paket nötig. Die Umgebung kommt als Funktion herein, damit Tests nichts mit os.Setenv verbiegen müssen.

cat > internal/config/config.go <<'EOF'
// Package config lädt Einstellungen: Default < Datei < Env (< Flag in main).
package config

import (
    "bufio"
    "fmt"
    "os"
    "regexp"
    "strings"
)

// Config hält die Einstellungen von kctxsafe.
type Config struct {
    ProdPattern string // regulärer Ausdruck für Produktionskontexte
}

// Load liest optional eine key=value-Datei und danach die Umgebung.
func Load(path string, getenv func(string) string) (Config, error) {
    c := Config{ProdPattern: "prod"}
    if path != "" {
        if err := c.readFile(path); err != nil {
            return c, err
        }
    }
    if v := getenv("KCTXSAFE_PROD_PATTERN"); v != "" {
        c.ProdPattern = v
    }
    return c, nil
}

func (c *Config) readFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close()
    sc := bufio.NewScanner(f)
    for n := 1; sc.Scan(); n++ {
        line := strings.TrimSpace(sc.Text())
        if line == "" || strings.HasPrefix(line, "#") {
            continue
        }
        key, val, ok := strings.Cut(line, "=")
        if !ok {
            return fmt.Errorf("%s:%d: erwartet key=value", path, n)
        }
        switch strings.TrimSpace(key) {
        case "prod_pattern":
            c.ProdPattern = strings.TrimSpace(val)
        default:
            return fmt.Errorf("%s:%d: unbekannter Schlüssel %q", path, n, key)
        }
    }
    return sc.Err()
}

// ProdRegexp kompiliert das Muster; Fehler meldet die Config, nicht der Wechsel.
func (c Config) ProdRegexp() (*regexp.Regexp, error) {
    re, err := regexp.Compile(c.ProdPattern)
    if err != nil {
        return nil, fmt.Errorf("prod_pattern: %w", err)
    }
    return re, nil
}
EOF
go vet ./internal/...

Erwartet: keine Ausgabe.

Warum? Unbekannte Schlüssel sind ein Fehler, kein stilles Ignorieren – ein Tippfehler wie prod_patern würde sonst den Schutz abschalten.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Die Schutzschranke

Ein y tippt man aus Reflex. Den Kontextnamen abzutippen zwingt zum Lesen – dasselbe Muster wie beim Löschen eines GitHub-Repos.

cat > internal/guard/guard.go <<'EOF'
// Package guard schützt Produktionskontexte vor versehentlichem Wechsel.
package guard

import (
    "bufio"
    "fmt"
    "io"
    "strings"
)

// Confirm fragt nach dem Kontextnamen. Nur exakt derselbe Name bestätigt.
func Confirm(in io.Reader, out io.Writer, name string) (bool, error) {
    fmt.Fprintf(out, "%s ist prod. Namen zum Bestätigen tippen: ", name)
    line, err := bufio.NewReader(in).ReadString('\n')
    if err != nil && err != io.EOF {
        return false, err
    }
    return strings.TrimSpace(line) == name, nil
}
EOF

Warum? io.Reader und io.Writer statt os.Stdin/os.Stderr: Im Test ist die Eingabe ein strings.Reader, die Ausgabe io.Discard.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Umbau auf cobra

go get github.com/spf13/[email protected]

Erwartet:

go: added github.com/inconshreveable/mousetrap v1.1.0
go: added github.com/spf13/cobra v1.10.2
go: added github.com/spf13/pflag v1.0.9

main bleibt winzig. newRoot bekommt kubectl-Runner, Umgebung und stdin von außen – genau die drei Dinge, die ein Test ersetzen will.

cat > cmd/kctxsafe/main.go <<'EOF'
// kctxsafe zeigt und wechselt kubeconfig-Kontexte – prod nur mit Bestätigung.
package main

import (
    "context"
    "io"
    "os"
    "os/signal"

    "example.com/kctxsafe/internal/kube"
    "github.com/spf13/cobra"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()
    root := newRoot(kube.ExecRunner, os.Getenv, os.Stdin)
    if err := root.ExecuteContext(ctx); err != nil {
        os.Exit(1)
    }
}

// newRoot baut den Befehlsbaum; Abhängigkeiten kommen von außen (testbar).
func newRoot(run kube.Runner, getenv func(string) string, in io.Reader,
) *cobra.Command {
    a := &app{run: run, getenv: getenv, in: in}
    root := &cobra.Command{
        Use:          "kctxsafe",
        Short:        "kubeconfig-Kontexte anzeigen und sicher wechseln",
        SilenceUsage: true,
    }
    pf := root.PersistentFlags()
    pf.StringVar(&a.kubeconfig, "kubeconfig", "", "Kubeconfig (sonst $KUBECONFIG)")
    pf.StringVar(&a.configFile, "config", "", "Config (sonst $KCTXSAFE_CONFIG)")
    pf.StringVar(&a.prodPattern, "prod-pattern", "", "Regex für prod-Kontexte")
    root.AddCommand(a.listCmd(), a.currentCmd(), a.useCmd())
    return root
}
EOF

Die Unterbefehle hängen an app. setup setzt die Reihenfolge Flag > Env > Datei > Default an einer einzigen Stelle durch.

cat > cmd/kctxsafe/app.go <<'EOF'
package main

import (
    "errors"
    "fmt"
    "io"
    "regexp"
    "strings"

    "example.com/kctxsafe/internal/config"
    "example.com/kctxsafe/internal/guard"
    "example.com/kctxsafe/internal/kube"
    "github.com/spf13/cobra"
)

type app struct {
    run                                 kube.Runner
    getenv                              func(string) string
    in                                  io.Reader
    kubeconfig, configFile, prodPattern string
}

// setup wertet Flag > Env > Datei > Default aus.
func (a *app) setup() (kube.Client, *regexp.Regexp, error) {
    path := first(a.kubeconfig, a.getenv("KUBECONFIG"))
    if path == "" {
        return kube.Client{}, nil, errors.New("--kubeconfig oder KUBECONFIG setzen")
    }
    if strings.Contains(path, ":") {
        return kube.Client{}, nil, errors.New("genau eine Kubeconfig-Datei erlaubt")
    }
    cfg, err := config.Load(first(a.configFile, a.getenv("KCTXSAFE_CONFIG")), a.getenv)
    if err != nil {
        return kube.Client{}, nil, err
    }
    if a.prodPattern != "" {
        cfg.ProdPattern = a.prodPattern
    }
    re, err := cfg.ProdRegexp()
    return kube.Client{Kubeconfig: path, Run: a.run}, re, err
}

func first(vals ...string) string {
    for _, v := range vals {
        if v != "" {
            return v
        }
    }
    return ""
}

func (a *app) listCmd() *cobra.Command {
    return &cobra.Command{
        Use:   "list",
        Short: "Kontexte auflisten (* = aktiv)",
        Args:  cobra.NoArgs,
        RunE: func(cmd *cobra.Command, _ []string) error {
            c, prod, err := a.setup()
            if err != nil {
                return err
            }
            names, err := c.Contexts(cmd.Context())
            if err != nil {
                return err
            }
            cur, _ := c.Current(cmd.Context()) // kein aktiver Kontext ist ok
            for _, n := range names {
                mark, tag := " ", ""
                if n == cur {
                    mark = "*"
                }
                if prod.MatchString(n) {
                    tag = "  [PROD]"
                }
                fmt.Fprintf(cmd.OutOrStdout(), "%s %s%s\n", mark, n, tag)
            }
            return nil
        },
    }
}

func (a *app) currentCmd() *cobra.Command {
    return &cobra.Command{
        Use:   "current",
        Short: "aktiven Kontext anzeigen",
        Args:  cobra.NoArgs,
        RunE: func(cmd *cobra.Command, _ []string) error {
            c, _, err := a.setup()
            if err != nil {
                return err
            }
            cur, err := c.Current(cmd.Context())
            if err != nil {
                return err
            }
            fmt.Fprintln(cmd.OutOrStdout(), cur)
            return nil
        },
    }
}

func (a *app) useCmd() *cobra.Command {
    var yes bool
    cmd := &cobra.Command{
        Use:   "use KONTEXT",
        Short: "Kontext wechseln (prod nur mit Bestätigung)",
        Args:  cobra.ExactArgs(1),
        RunE: func(cmd *cobra.Command, args []string) error {
            c, prod, err := a.setup()
            if err != nil {
                return err
            }
            name := args[0]
            if prod.MatchString(name) && !yes {
                ok, err := guard.Confirm(a.in, cmd.ErrOrStderr(), name)
                if err != nil {
                    return err
                }
                if !ok {
                    return errors.New("abgebrochen, Kontext unverändert")
                }
            }
            if err := c.Use(cmd.Context(), name); err != nil {
                return err
            }
            fmt.Fprintf(cmd.OutOrStdout(), "Kontext jetzt: %s\n", name)
            return nil
        },
    }
    cmd.Flags().BoolVarP(&yes, "yes", "y", false, "ohne Rückfrage (für Skripte)")
    return cmd
}
EOF
go mod tidy
go build -o kctxsafe ./cmd/kctxsafe
./kctxsafe list
./kctxsafe use staging
echo nein | ./kctxsafe use prod-eu; echo "Exit: $?"
echo prod-eu | ./kctxsafe use prod-eu
./kctxsafe use kind-dev

Erwartet:

* kind-dev
  prod-eu  [PROD]
  staging
Kontext jetzt: staging
prod-eu ist prod. Namen zum Bestätigen tippen: Error: abgebrochen, Kontext unverändert
Exit: 1
prod-eu ist prod. Namen zum Bestätigen tippen: Kontext jetzt: prod-eu
Kontext jetzt: kind-dev

Warum? SilenceUsage: true verhindert, dass cobra bei jedem Laufzeitfehler die komplette Hilfe ausgibt; Fehler landen trotzdem als Error: … auf stderr. ExecuteContext reicht den Signal-Context bis in cmd.Context() und damit bis zu kubectl durch.

Jetzt die Konfigurationsquellen gegeneinander:

printf '# kctxsafe-Lab\nprod_pattern=prod|staging\n' > kctxsafe.conf
./kctxsafe list --config kctxsafe.conf
KCTXSAFE_CONFIG=kctxsafe.conf KCTXSAFE_PROD_PATTERN='^kind' ./kctxsafe list
./kctxsafe list --prod-pattern '('
./kctxsafe --kubeconfig a.yaml:b.yaml list
./kctxsafe use gibtsnicht

Erwartet:

* kind-dev
  prod-eu  [PROD]
  staging  [PROD]
* kind-dev  [PROD]
  prod-eu
  staging
Error: prod_pattern: error parsing regexp: missing closing ): `(`
Error: genau eine Kubeconfig-Datei erlaubt
Error: kubectl: error: no context exists with the name: "gibtsnicht"

Tipp: ./kctxsafe completion zsh erzeugt die Shell-Vervollständigung gratis – cobra hängt den Befehl automatisch an.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Tests mit Fake-kubectl

Zuerst die kleinen Pakete, table-driven wie in Tag 4:

cat > internal/guard/guard_test.go <<'EOF'
package guard

import (
    "io"
    "strings"
    "testing"
)

func TestConfirm(t *testing.T) {
    tests := []struct {
        name, input string
        want        bool
    }{
        {"exakter Name", "prod-eu\n", true},
        {"ohne Zeilenende", "prod-eu", true},
        {"nur y", "y\n", false},
        {"leer", "", false},
        {"anderer Kontext", "prod-us\n", false},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := Confirm(strings.NewReader(tt.input), io.Discard, "prod-eu")
            if err != nil {
                t.Fatal(err)
            }
            if got != tt.want {
                t.Errorf("Confirm(%q) = %v, want %v", tt.input, got, tt.want)
            }
        })
    }
}
EOF
cat > internal/config/config_test.go <<'EOF'
package config

import (
    "os"
    "path/filepath"
    "testing"
)

func TestLoadReihenfolge(t *testing.T) {
    path := filepath.Join(t.TempDir(), "kctxsafe.conf")
    content := "# Lab\nprod_pattern = prod|live\n"
    if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
        t.Fatal(err)
    }
    env := map[string]string{}
    getenv := func(k string) string { return env[k] }

    tests := []struct {
        name, path, envVal, want string
    }{
        {"Default", "", "", "prod"},
        {"Datei", path, "", "prod|live"},
        {"Env schlägt Datei", path, "^p-", "^p-"},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            env["KCTXSAFE_PROD_PATTERN"] = tt.envVal
            c, err := Load(tt.path, getenv)
            if err != nil {
                t.Fatal(err)
            }
            if c.ProdPattern != tt.want {
                t.Errorf("ProdPattern = %q, want %q", c.ProdPattern, tt.want)
            }
        })
    }
}
EOF

Dann das CLI als Ganzes: newRoot mit Fake-Runner, SetArgs statt os.Args, Ausgabe in einen Puffer. Der wichtigste Fall: y statt des Namens darf kein use-context auslösen. Der Integrationstest nutzt echtes kubectl auf einer Kopie der Lab-Datei in t.TempDir() und überspringt sich ohne kubectl.

cat > cmd/kctxsafe/main_test.go <<'EOF'
package main

import (
    "bytes"
    "context"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
    "testing"

    "example.com/kctxsafe/internal/kube"
)

// fakeKubectl antwortet wie kubectl und merkt sich, ob gewechselt wurde.
type fakeKubectl struct{ switched bool }

func (f *fakeKubectl) run(_ context.Context, _ string, args ...string) ([]byte, error) {
    switch args[1] {
    case "get-contexts":
        return []byte("kind-dev\nprod-eu\n"), nil
    case "current-context":
        return []byte("kind-dev\n"), nil
    case "use-context":
        f.switched = true
    }
    return nil, nil
}

// execute startet das CLI wie von der Shell, nur ohne Prozess.
func execute(t *testing.T, run kube.Runner, kc, stdin string, args ...string) (
    string, error) {
    t.Helper()
    root := newRoot(run, func(string) string { return "" }, strings.NewReader(stdin))
    var out bytes.Buffer
    root.SetOut(&out)
    root.SetErr(&out)
    root.SetArgs(append([]string{"--kubeconfig", kc}, args...))
    err := root.Execute()
    return out.String(), err
}

func labKubeconfig(t *testing.T) string {
    t.Helper()
    src, err := os.ReadFile("../../lab-kubeconfig.yaml")
    if err != nil {
        t.Fatal(err)
    }
    kc := filepath.Join(t.TempDir(), "kubeconfig") // Kopie, Original bleibt
    if err := os.WriteFile(kc, src, 0o600); err != nil {
        t.Fatal(err)
    }
    return kc
}

func TestUse(t *testing.T) {
    tests := []struct {
        name, stdin string
        args        []string
        wantSwitch  bool
    }{
        {"dev ohne Frage", "", []string{"use", "kind-dev"}, true},
        {"prod mit y", "y\n", []string{"use", "prod-eu"}, false},
        {"prod mit Namen", "prod-eu\n", []string{"use", "prod-eu"}, true},
        {"prod mit --yes", "", []string{"use", "prod-eu", "--yes"}, true},
    }
    kc := labKubeconfig(t)
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            f := &fakeKubectl{}
            _, err := execute(t, f.run, kc, tt.stdin, tt.args...)
            if f.switched != tt.wantSwitch || (err == nil) != tt.wantSwitch {
                t.Errorf("switched=%v err=%v, want switch %v",
                    f.switched, err, tt.wantSwitch)
            }
        })
    }
}

func TestListMarkiert(t *testing.T) {
    out, err := execute(t, (&fakeKubectl{}).run, labKubeconfig(t), "", "list")
    if want := "* kind-dev\n  prod-eu  [PROD]\n"; err != nil || out != want {
        t.Errorf("list = %q, %v; want %q", out, err, want)
    }
}

// Integration: echtes kubectl auf einer Kopie der Lab-Kubeconfig.
func TestEchtesKubectl(t *testing.T) {
    if _, err := exec.LookPath("kubectl"); err != nil {
        t.Skip("kubectl nicht installiert")
    }
    kc := labKubeconfig(t)
    if _, err := execute(t, kube.ExecRunner, kc, "", "use", "staging"); err != nil {
        t.Fatal(err)
    }
    if out, _ := execute(t, kube.ExecRunner, kc, "", "current"); out != "staging\n" {
        t.Errorf("current = %q, want staging", out)
    }
}
EOF
go test -race -count=1 ./...
go test -count=1 -v -run TestUse ./cmd/kctxsafe

Erwartet (gekürzt):

ok      example.com/kctxsafe/cmd/kctxsafe   1.382s
ok      example.com/kctxsafe/internal/config    1.421s
ok      example.com/kctxsafe/internal/guard 1.150s
?       example.com/kctxsafe/internal/kube  [no test files]
--- PASS: TestUse (0.00s)
    --- PASS: TestUse/dev_ohne_Frage (0.00s)
    --- PASS: TestUse/prod_mit_y (0.00s)
    --- PASS: TestUse/prod_mit_Namen (0.00s)
    --- PASS: TestUse/prod_mit_--yes (0.00s)
PASS

Warum? Weil der Runner eine Funktion ist, braucht der Test kein Mock-Framework. kube hat keine eigenen Tests, wird aber über cmd/kctxsafe mitgetestet – go test -coverpkg=./... ./... zeigt das.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

golangci-lint (Tag 0) mahnt sonst jedes ungeprüfte fmt.Fprintf an. Die Voreinstellung std-error-handling nimmt diese Standardfälle aus:

cat > .golangci.yml <<'EOF'
version: "2"
linters:
  exclusions:
    presets: [std-error-handling] # fmt.Fprint*, Close & Co. nicht anmahnen
EOF
gofmt -l . && go vet ./... && ~/go-lab/bin/lint run ./...
go build -o kctxsafe ./cmd/kctxsafe
./kctxsafe --help | tail -6
./kctxsafe use prod-eu --yes && ./kctxsafe current && ./kctxsafe use kind-dev

Erwartet:

0 issues.
      --config string         Config (sonst $KCTXSAFE_CONFIG)
  -h, --help                  help for kctxsafe
      --kubeconfig string     Kubeconfig (sonst $KUBECONFIG)
      --prod-pattern string   Regex für prod-Kontexte

Use "kctxsafe [command] --help" for more information about a command.
Kontext jetzt: prod-eu
prod-eu
Kontext jetzt: kind-dev

Mit deinem echten Setup würdest du kctxsafe später bewusst per --kubeconfig ~/.kube/config aufrufen – im Lab nicht.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/go-lab/tag05-kctxsafe && export KUBECONFIG=$PWD/lab-kubeconfig.yaml
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
go vet ./... && go test -count=1 ./... >/dev/null && ok "vet + Tests" || nok "Tests"
./kctxsafe list | grep -q 'prod-eu  \[PROD\]' && ok "prod markiert" || nok "list"
echo y | ./kctxsafe use prod-eu 2>/dev/null && nok "prod ohne Namen" \
  || ok "prod blockiert"
[ "$(./kctxsafe current)" = kind-dev ] && ok "Kontext unverändert" || nok "current"
KUBECONFIG= ./kctxsafe list 2>/dev/null && nok "Fallback!" || ok "kein Fallback"

Erwartet:

✔ vet + Tests
✔ prod markiert
✔ prod blockiert
✔ Kontext unverändert
✔ kein Fallback

Challenge

Baue kctxsafe check: Exit-Code 0, wenn der aktive Kontext nicht prod ist, sonst Exit-Code 2 – für den Shell-Prompt oder als Guard vor helm upgrade in Skripten.

Hinweis: cobra kennt nur „Fehler oder nicht”; definiere einen Sentinel-Fehler (Tag 3) und werte ihn in main mit errors.Is aus.

Lösung

In app.go anhängen:

cat >> cmd/kctxsafe/app.go <<'EOF'

// errProd meldet main: aktiver Kontext ist prod -> Exit-Code 2.
var errProd = errors.New("aktiver Kontext ist prod")

func (a *app) checkCmd() *cobra.Command {
    return &cobra.Command{
        Use:   "check",
        Short: "Exit 2, wenn der aktive Kontext prod ist (für Prompt/CI)",
        Args:  cobra.NoArgs,
        RunE: func(cmd *cobra.Command, _ []string) error {
            c, prod, err := a.setup()
            if err != nil {
                return err
            }
            cur, err := c.Current(cmd.Context())
            if err != nil {
                return err
            }
            if prod.MatchString(cur) {
                return errProd
            }
            return nil
        },
    }
}
EOF

In main.go den Befehl registrieren (root.AddCommand(…, a.checkCmd())), "errors" importieren und den Exit-Code unterscheiden:

    if err := root.ExecuteContext(ctx); err != nil {
        if errors.Is(err, errProd) {
            os.Exit(2)
        }
        os.Exit(1)
    }
go build -o kctxsafe ./cmd/kctxsafe
./kctxsafe check; echo "Exit: $?"
./kctxsafe use prod-eu -y >/dev/null; ./kctxsafe check; echo "Exit: $?"
./kctxsafe use kind-dev

Erwartet:

Exit: 0
Error: aktiver Kontext ist prod
Exit: 2
Kontext jetzt: kind-dev

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Echte Kubeconfigs enthalten Tokens und Client-Zertifikate: Datei mit 0600, nie ins Repo; besser kurzlebige Credentials per exec-Plugin (OIDC, kubelogin, Vault/OpenBao-Kubernetes-Secrets-Engine).
  • Pro Umgebung eine eigene Kubeconfig-Datei (KUBECONFIG=~/.kube/prod.yaml nur in der Prod-Shell) ist robuster als ein Kontextwechsel in einer gemeinsamen Datei.
  • Die Bestätigung ersetzt kein RBAC: prod-Rechte gehören an eine eigene Rolle mit Freigabe (Break-Glass), nicht an jeden Entwickler-Account.
  • os/exec nie mit sh -c und zusammengesetzten Strings – Argumente immer einzeln übergeben, sonst Command Injection.
  • Für Team-Rollout: Binary per Release verteilen (Tag 14), Version per -ldflags (Tag 0) und Shell-Completion mitliefern.