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 umkubectl config.- Erst
flagaus der Standardbibliothek, dann Umbau auf cobra mit Unterbefehlen. - Konfiguration in fester Reihenfolge: Default < Datei < Env < Flag.
os/execruft 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.yamlim Lab-Ordner. Deine echte~/.kube/configbleibt unberührt –kctxsafehat 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/guardErwartet:
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
EOFexport KUBECONFIG=$PWD/lab-kubeconfig.yaml # nur in dieser Shell
kubectl config get-contexts -o name
kubectl config current-contextErwartet:
kind-dev
prod-eu
staging
kind-dev
Achtung: Öffne für dieses Kapitel eine eigene Terminal-Session. So kann ein vergessenes
export KUBECONFIGkeine 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
}
EOFWarum? 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 -hErwartet (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
}
EOFgo 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
}
EOFWarum? 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
}
EOFDie 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
}
EOFgo 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-devErwartet:
* 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 gibtsnichtErwartet:
* 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 zsherzeugt 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)
}
})
}
}
EOFcat > 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)
}
})
}
}
EOFDann 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)
}
}
EOFgo test -race -count=1 ./...
go test -count=1 -v -run TestUse ./cmd/kctxsafeErwartet (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
EOFgofmt -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-devErwartet:
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
},
}
}
EOFIn 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-devErwartet:
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 perexec-Plugin (OIDC,kubelogin, Vault/OpenBao-Kubernetes-Secrets-Engine). - Pro Umgebung eine eigene Kubeconfig-Datei
(
KUBECONFIG=~/.kube/prod.yamlnur 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/execnie mitsh -cund 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.