Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 6: Dateien, io, JSON und YAML – manifestlint

Ziel: Ein Linter, der Kubernetes-YAMLs auf :latest, fehlende Ressourcen und fehlende Labels prüft – als Text oder JSON, mit sauberen Exit-Codes · Dauer: ca. 120 min · Voraussetzung: Tag 5

Briefing

  • YAML mit go.yaml.in/yaml/v3 in schmale Structs dekodieren – nur die Felder, die du prüfst.
  • Mehrere Dokumente pro Datei (---) per Decoder-Schleife bis io.EOF.
  • Verzeichnisse mit filepath.WalkDir, stdin über io.Reader – derselbe Code für Datei und Pipe.
  • Ausgabe mit encoding/json und Struct-Tags; Exit-Code 0/1/2 für CI.
  • Golden File (Tag 4) sichert das JSON-Format ab.
PFAD... --> Files() --> LintFile() --> Decode() --> Check() --> text | json
  "-" = stdin       os.Open/io.Reader    yaml      Regeln       Exit 0/1/2

Drill 1: Modul und Beispielmanifeste

mkdir -p ~/go-lab/tag06-manifestlint && cd ~/go-lab/tag06-manifestlint
go mod init example.com/manifestlint
go get go.yaml.in/yaml/[email protected]
mkdir -p cmd/manifestlint/testdata internal/lint manifests/app manifests/.cache

Erwartet:

go: creating new go.mod: module example.com/manifestlint
go: added go.yaml.in/yaml/v3 v3.0.5

Warum go.yaml.in? Das alte gopkg.in/yaml.v3 wird nicht mehr gepflegt; das YAML-Team der Go-Community führt es unter diesem Pfad weiter.

Zwei Manifeste mit absichtlichen Fehlern, dazu ein Köder im versteckten .cache-Ordner und eine Nicht-YAML-Datei:

cat > manifests/app/web.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  labels: {app.kubernetes.io/name: web}
spec:
  replicas: 2
  selector: {matchLabels: {app.kubernetes.io/name: web}}
  template:
    metadata: {labels: {app.kubernetes.io/name: web}}
    spec:
      initContainers:
      - name: migrate
        image: registry.local:5000/migrate
        resources:
          requests: {cpu: 50m, memory: 64Mi}
          limits: {memory: 64Mi}
      containers:
      - name: web
        image: nginx:latest
        resources:
          requests: {cpu: 100m}
---
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  selector: {app.kubernetes.io/name: web}
  ports: [{port: 80}]
EOF
cat > manifests/backup.yml <<'EOF'
apiVersion: batch/v1
kind: CronJob
metadata:
  name: backup
  labels: {app.kubernetes.io/name: backup}
spec:
  schedule: "0 3 * * *"
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
          - name: backup
            image: "ghcr.io/example/backup@sha256:\
              0b8a3f6c2d1e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a"
            resources:
              requests: {cpu: 1, memory: 256Mi}
              limits: {memory: 256Mi}
EOF

Der \ am Zeilenende im doppelt gequoteten Image-String bricht den langen Digest um, ohne ein Leerzeichen einzufügen.

echo "kind: Pod" > manifests/.cache/ignoriert.yaml
echo "# Doku" > manifests/README.md

Fortschritt speichern? Kostenlos registrieren

Drill 2: YAML in Structs

Ein Kubernetes-Objekt hat hunderte Felder – du deklarierst nur die gebrauchten. Unbekannte Felder ignoriert der Decoder. Die Container stecken je nach kind an drei verschiedenen Stellen.

cat > internal/lint/manifest.go <<'EOF'
// Package lint prüft Kubernetes-Manifeste auf typische Produktionsfehler.
package lint

import (
    "errors"
    "fmt"
    "io"

    "go.yaml.in/yaml/v3"
)

// Manifest enthält nur die Felder, die die Regeln brauchen.
type Manifest struct {
    Kind     string `yaml:"kind"`
    Metadata struct {
        Name   string            `yaml:"name"`
        Labels map[string]string `yaml:"labels"`
    } `yaml:"metadata"`
    Spec struct {
        PodSpec  `yaml:",inline"` // Pod
        Template struct {
            Spec PodSpec `yaml:"spec"`
        } `yaml:"template"` // Deployment, StatefulSet, DaemonSet, Job
        JobTemplate struct {
            Spec struct {
                Template struct {
                    Spec PodSpec `yaml:"spec"`
                } `yaml:"template"`
            } `yaml:"spec"`
        } `yaml:"jobTemplate"` // CronJob
    } `yaml:"spec"`
}

// PodSpec ist der Teil, in dem Container stehen.
type PodSpec struct {
    Containers     []Container `yaml:"containers"`
    InitContainers []Container `yaml:"initContainers"`
}

// Container mit Image und Ressourcen.
type Container struct {
    Name      string `yaml:"name"`
    Image     string `yaml:"image"`
    Resources struct {
        Requests map[string]string `yaml:"requests"`
        Limits   map[string]string `yaml:"limits"`
    } `yaml:"resources"`
}

// Pod liefert die PodSpec je nach Kind, sonst nil.
func (m *Manifest) Pod() *PodSpec {
    switch m.Kind {
    case "Pod":
        return &m.Spec.PodSpec
    case "Deployment", "StatefulSet", "DaemonSet", "ReplicaSet", "Job":
        return &m.Spec.Template.Spec
    case "CronJob":
        return &m.Spec.JobTemplate.Spec.Template.Spec
    }
    return nil
}

// Decode liest alle YAML-Dokumente (getrennt durch ---) aus r.
func Decode(r io.Reader) ([]Manifest, error) {
    dec := yaml.NewDecoder(r)
    var out []Manifest
    for i := 1; ; i++ {
        var m Manifest
        err := dec.Decode(&m)
        if errors.Is(err, io.EOF) {
            return out, nil
        }
        if err != nil {
            return out, fmt.Errorf("%d. Dokument: %w", i, err)
        }
        if m.Kind != "" { // leere Dokumente überspringen
            out = append(out, m)
        }
    }
}
EOF

Warum? yaml:",inline" hängt die Felder von PodSpec direkt unter spec ein (Pod), während Deployments sie unter spec.template.spec haben. errors.Is(err, io.EOF) ist das reguläre Ende der Schleife, kein Fehler.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Die Regeln

cat > internal/lint/rules.go <<'EOF'
package lint

import (
    "fmt"
    "slices"
    "strings"
)

// Finding ist ein Verstoß; die JSON-Tags bestimmen die Ausgabe mit -o json.
type Finding struct {
    File    string `json:"file"`
    Kind    string `json:"kind"`
    Name    string `json:"name"`
    Rule    string `json:"rule"`
    Message string `json:"message"`
}

// Check wendet alle Regeln auf ein Manifest an.
func Check(m Manifest, requiredLabels []string) []Finding {
    var fs []Finding
    add := func(rule, format string, args ...any) {
        fs = append(fs, Finding{Kind: m.Kind, Name: m.Metadata.Name,
            Rule: rule, Message: fmt.Sprintf(format, args...)})
    }
    for _, l := range requiredLabels {
        if _, ok := m.Metadata.Labels[l]; !ok {
            add("label", "%s fehlt", l)
        }
    }
    pod := m.Pod()
    if pod == nil {
        return fs
    }
    for _, c := range slices.Concat(pod.InitContainers, pod.Containers) {
        if floatingTag(c.Image) {
            add("image-tag", "%s: %s", c.Name, c.Image)
        }
        for _, k := range []string{"cpu", "memory"} {
            if c.Resources.Requests[k] == "" {
                add("resources", "%s: requests.%s fehlt", c.Name, k)
            }
        }
        if c.Resources.Limits["memory"] == "" {
            add("resources", "%s: limits.memory fehlt", c.Name)
        }
    }
    return fs
}

// floatingTag erkennt :latest und fehlende Tags; Digests sind immer fest.
func floatingTag(image string) bool {
    if strings.Contains(image, "@sha256:") {
        return false
    }
    last := image[strings.LastIndex(image, "/")+1:] // Registry-Port ignorieren
    name, tag, ok := strings.Cut(last, ":")
    return name == "" || !ok || tag == "latest"
}
EOF
go vet ./...

Erwartet: keine Ausgabe.

Warum slices.Concat statt append(pod.InitContainers, pod.Containers...)? append darf in das Array von InitContainers schreiben, wenn dort Kapazität frei ist – ein klassischer Aliasing-Fehler. Concat legt immer ein neues Slice an.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Dateien finden und lesen

filepath.WalkDir ruft deine Funktion für jeden Eintrag auf; filepath.SkipDir überspringt einen ganzen Teilbaum. LintFile arbeitet nur mit io.Reader – ob Datei oder stdin, ist dem Decoder egal.

cat > internal/lint/files.go <<'EOF'
package lint

import (
    "fmt"
    "io"
    "io/fs"
    "os"
    "path/filepath"
    "strings"
)

// Files sammelt Manifeste: genannte Dateien immer, in Verzeichnissen nur
// *.yaml/*.yml. Versteckte Verzeichnisse (.git) werden übersprungen.
func Files(paths []string) ([]string, error) {
    var out []string
    for _, root := range paths {
        if root == "-" { // stdin
            out = append(out, root)
            continue
        }
        err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
            switch {
            case err != nil:
                return err
            case d.IsDir() && p != root && strings.HasPrefix(d.Name(), "."):
                return filepath.SkipDir
            case !d.IsDir() && (p == root || isYAML(p)):
                out = append(out, p)
            }
            return nil
        })
        if err != nil {
            return nil, err
        }
    }
    return out, nil
}

func isYAML(p string) bool {
    ext := filepath.Ext(p)
    return ext == ".yaml" || ext == ".yml"
}

// LintFile liest eine Datei (oder stdin) und prüft alle Dokumente darin.
func LintFile(path string, labels []string) ([]Finding, error) {
    var r io.Reader = os.Stdin
    if path != "-" {
        f, err := os.Open(path)
        if err != nil {
            return nil, err
        }
        defer f.Close()
        r = f
    }
    ms, err := Decode(r)
    if err != nil {
        return nil, fmt.Errorf("%s: %w", path, err)
    }
    var out []Finding
    for _, m := range ms {
        for _, f := range Check(m, labels) {
            f.File = path
            out = append(out, f)
        }
    }
    return out, nil
}
EOF

Warum defer f.Close() direkt nach dem Fehlercheck? So wird die Datei auf jedem Rückweg geschlossen – auch wenn Decode scheitert. Bei nur lesend geöffneten Dateien ist der Fehler von Close bedeutungslos.

Fortschritt speichern? Kostenlos registrieren

Drill 5: CLI, JSON und Exit-Codes

run statt Logik in main: Argumente und Writer kommen herein, ein Exit-Code geht hinaus – damit ist das ganze CLI testbar. flag.Func baut ein wiederholbares Flag ohne eigenen Typ.

cat > cmd/manifestlint/main.go <<'EOF'
// manifestlint prüft Kubernetes-YAMLs. Exit 0 = sauber, 1 = Befunde, 2 = Fehler.
package main

import (
    "encoding/json"
    "flag"
    "fmt"
    "io"
    "os"

    "example.com/manifestlint/internal/lint"
)

func main() {
    os.Exit(run(os.Args[1:], os.Stdout, os.Stderr))
}

func run(args []string, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("manifestlint", flag.ContinueOnError)
    fl.SetOutput(stderr)
    format := fl.String("o", "text", "Ausgabe: text oder json")
    var labels []string
    fl.Func("label", "Pflicht-Label (mehrfach; Default app.kubernetes.io/name)",
        func(s string) error { labels = append(labels, s); return nil })
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if len(labels) == 0 {
        labels = []string{"app.kubernetes.io/name"}
    }
    if fl.NArg() == 0 {
        fmt.Fprintln(stderr, "Aufruf: manifestlint [-o json] [-label k] PFAD...")
        return 2
    }

    files, err := lint.Files(fl.Args())
    if err != nil {
        fmt.Fprintln(stderr, "manifestlint:", err)
        return 2
    }
    findings := []lint.Finding{} // leer statt nil: JSON wird [] statt null
    for _, f := range files {
        fs, err := lint.LintFile(f, labels)
        if err != nil {
            fmt.Fprintln(stderr, "manifestlint:", err)
            return 2
        }
        findings = append(findings, fs...)
    }

    switch *format {
    case "json":
        enc := json.NewEncoder(stdout)
        enc.SetIndent("", "  ")
        if err := enc.Encode(findings); err != nil {
            fmt.Fprintln(stderr, "manifestlint:", err)
            return 2
        }
    case "text":
        for _, f := range findings {
            fmt.Fprintf(stdout, "%s %s/%s %s: %s\n",
                f.File, f.Kind, f.Name, f.Rule, f.Message)
        }
        fmt.Fprintf(stdout, "%d Datei(en), %d Befund(e)\n", len(files), len(findings))
    default:
        fmt.Fprintf(stderr, "manifestlint: unbekanntes Format %q\n", *format)
        return 2
    }
    if len(findings) > 0 {
        return 1
    }
    return 0
}
EOF
go build -o manifestlint ./cmd/manifestlint
./manifestlint manifests; echo "Exit: $?"
./manifestlint -o json manifests/backup.yml; echo "Exit: $?"

Erwartet:

manifests/app/web.yaml Deployment/web image-tag: migrate: registry.local:5000/migrate
manifests/app/web.yaml Deployment/web image-tag: web: nginx:latest
manifests/app/web.yaml Deployment/web resources: web: requests.memory fehlt
manifests/app/web.yaml Deployment/web resources: web: limits.memory fehlt
manifests/app/web.yaml Service/web label: app.kubernetes.io/name fehlt
2 Datei(en), 5 Befund(e)
Exit: 1
[]
Exit: 0

README.md und .cache/ignoriert.yaml tauchen nicht auf, der Registry-Port :5000 wird nicht für einen Tag gehalten, und der Digest im CronJob gilt als fest. cpu: 1 ist in YAML eine Zahl – der Decoder legt sie trotzdem als String "1" ab.

Jetzt die Fehlerpfade:

./manifestlint; echo "Exit: $?"
./manifestlint -o xml manifests; echo "Exit: $?"
printf 'kind: Pod\n---\nmetadata: [kaputt\n' > manifests/kaputt.yaml
./manifestlint manifests; echo "Exit: $?"
rm manifests/kaputt.yaml

Erwartet (gekürzt):

Aufruf: manifestlint [-o json] [-label k] PFAD...
Exit: 2
manifestlint: unbekanntes Format "xml"
Exit: 2
manifestlint: manifests/kaputt.yaml: 2. Dokument: yaml: line 2: did not find expected…
Exit: 2

Warum drei Exit-Codes? Eine CI-Pipeline muss „Manifest schlecht” (1) von „Linter kaputt” (2) unterscheiden können – sonst wird ein Syntaxfehler als Stilfrage weggeklickt.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Unit-Tests mit Strings und TempDir

Regeln und Decoder testest du ohne Dateien: strings.NewReader ist ein io.Reader. Eine Map als Testtabelle reicht, wenn die Reihenfolge egal ist.

cat > internal/lint/rules_test.go <<'EOF'
package lint

import (
    "strings"
    "testing"
)

func TestFloatingTag(t *testing.T) {
    tests := map[string]bool{
        "nginx":                          true,
        "nginx:latest":                   true,
        "nginx:1.27":                     false,
        "registry.local:5000/app":        true,
        "registry.local:5000/app:1.0":    false,
        "ghcr.io/x/app@sha256:0b8a3f6c2": false,
    }
    for image, want := range tests {
        t.Run(image, func(t *testing.T) {
            if got := floatingTag(image); got != want {
                t.Errorf("floatingTag(%q) = %v, want %v", image, got, want)
            }
        })
    }
}

const multiDoc = `
kind: Pod
metadata: {name: ok, labels: {app.kubernetes.io/name: ok}}
spec:
  containers:
  - name: app
    image: nginx:1.27
    resources: {requests: {cpu: 1, memory: 1Gi}, limits: {memory: 1Gi}}
---
# leeres Dokument
---
kind: CronJob
metadata: {name: nightly}
spec:
  jobTemplate: {spec: {template: {spec: {containers: [{name: job, image: x}]}}}}
`

func TestDecodeUndCheck(t *testing.T) {
    ms, err := Decode(strings.NewReader(multiDoc))
    if err != nil {
        t.Fatal(err)
    }
    if len(ms) != 2 {
        t.Fatalf("%d Manifeste, want 2", len(ms))
    }
    if fs := Check(ms[0], []string{"app.kubernetes.io/name"}); len(fs) != 0 {
        t.Errorf("Pod: unerwartete Befunde %v", fs)
    }
    var rules []string
    for _, f := range Check(ms[1], []string{"app.kubernetes.io/name"}) {
        rules = append(rules, f.Rule)
    }
    want := "label image-tag resources resources resources"
    if got := strings.Join(rules, " "); got != want {
        t.Errorf("CronJob: Regeln %q, want %q", got, want)
    }
}

func TestDecodeFehler(t *testing.T) {
    _, err := Decode(strings.NewReader("kind: Pod\n---\nmetadata: [kaputt\n"))
    if err == nil || !strings.Contains(err.Error(), "2. Dokument") {
        t.Errorf("err = %v, want Hinweis auf 2. Dokument", err)
    }
}
EOF

Das Dateisuchen bekommt einen echten, aber wegwerfbaren Verzeichnisbaum:

cat > internal/lint/files_test.go <<'EOF'
package lint

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

func TestFiles(t *testing.T) {
    dir := t.TempDir()
    for _, p := range []string{"a.yaml", "sub/b.yml", "README.md", ".git/c.yaml"} {
        full := filepath.Join(dir, p)
        if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
            t.Fatal(err)
        }
        if err := os.WriteFile(full, nil, 0o644); err != nil {
            t.Fatal(err)
        }
    }
    got, err := Files([]string{dir, filepath.Join(dir, "README.md"), "-"})
    if err != nil {
        t.Fatal(err)
    }
    want := []string{
        filepath.Join(dir, "a.yaml"), filepath.Join(dir, "sub/b.yml"),
        filepath.Join(dir, "README.md"), "-", // explizit genannt: immer dabei
    }
    if !slices.Equal(got, want) {
        t.Errorf("Files =\n%v\nwant\n%v", got, want)
    }
}
EOF
go test -count=1 -v ./internal/lint 2>&1 | grep -E '^(---|ok|FAIL)'

Erwartet:

--- PASS: TestFiles (0.00s)
--- PASS: TestFloatingTag (0.00s)
--- PASS: TestDecodeUndCheck (0.00s)
--- PASS: TestDecodeFehler (0.00s)
ok      example.com/manifestlint/internal/lint  0.244s

Fortschritt speichern? Kostenlos registrieren

Drill 7: Golden File für das JSON

Das JSON ist eine Schnittstelle – andere Tools parsen es. Ein Golden File (Tag 4) meldet jede Formatänderung. Testeingabe ist eine Kopie von web.yaml in testdata/, das go build ignoriert.

cp manifests/app/web.yaml cmd/manifestlint/testdata/web.yaml
cat > cmd/manifestlint/main_test.go <<'EOF'
package main

import (
    "bytes"
    "flag"
    "io"
    "os"
    "testing"
)

var update = flag.Bool("update", false, "Golden Files neu schreiben")

func TestJSONGolden(t *testing.T) {
    var out bytes.Buffer
    code := run([]string{"-o", "json", "testdata/web.yaml"}, &out, io.Discard)
    if code != 1 {
        t.Errorf("Exit-Code %d, want 1", code)
    }
    golden := "testdata/web.golden.json"
    if *update {
        if err := os.WriteFile(golden, out.Bytes(), 0o644); err != nil {
            t.Fatal(err)
        }
    }
    want, err := os.ReadFile(golden)
    if err != nil {
        t.Fatal(err)
    }
    if !bytes.Equal(out.Bytes(), want) {
        t.Errorf("Ausgabe weicht ab:\n%s", out.String())
    }
}

func TestExitCodes(t *testing.T) {
    tests := []struct {
        name string
        args []string
        want int
    }{
        {"ohne Pfad", nil, 2},
        {"fehlt", []string{"gibt-es-nicht.yaml"}, 2},
        {"Format", []string{"-o", "xml", "testdata/web.yaml"}, 2},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := run(tt.args, io.Discard, io.Discard); got != tt.want {
                t.Errorf("Exit-Code %d, want %d", got, tt.want)
            }
        })
    }
}
EOF
go test ./cmd/manifestlint -update
head -8 cmd/manifestlint/testdata/web.golden.json
go test -race -count=1 ./...

Erwartet:

ok      example.com/manifestlint/cmd/manifestlint   0.143s
[
  {
    "file": "testdata/web.yaml",
    "kind": "Deployment",
    "name": "web",
    "rule": "image-tag",
    "message": "migrate: registry.local:5000/migrate"
ok      example.com/manifestlint/cmd/manifestlint   1.151s
ok      example.com/manifestlint/internal/lint  1.307s

Achtung: Nach -update immer git diff testdata/ lesen. Ein blind aktualisiertes Golden File testet nichts mehr.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

.golangci.yml wie an Tag 5 übernehmen, dann alles prüfen und das Tool in eine Pipe hängen. kubectl create --dry-run=client erzeugt YAML ganz ohne Cluster; KUBECONFIG=/dev/null stellt sicher, dass kubectl keine echte Konfiguration anfasst.

cp ../tag05-kctxsafe/.golangci.yml .
gofmt -l . && go vet ./... && ~/go-lab/bin/lint run ./...
go build -o manifestlint ./cmd/manifestlint
KUBECONFIG=/dev/null kubectl create deployment demo --image=nginx:1.27 \
  --dry-run=client -o yaml | ./manifestlint -label team -
./manifestlint -o json manifests | jq -r '.[].rule' | sort | uniq -c

Erwartet:

0 issues.
- Deployment/demo label: team fehlt
- Deployment/demo resources: nginx: requests.cpu fehlt
- Deployment/demo resources: nginx: requests.memory fehlt
- Deployment/demo resources: nginx: limits.memory fehlt
1 Datei(en), 4 Befund(e)
   2 image-tag
   1 label
   2 resources

Mit -label team ersetzt du das Default-Label; für beide gibst du -label zweimal an. Genauso funktioniert kubectl kustomize overlays/prod | ./manifestlint - oder helm template … | ./manifestlint -.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/go-lab/tag06-manifestlint
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
go vet ./... && go test -count=1 ./... >/dev/null && ok "vet + Tests" || nok "Tests"
./manifestlint manifests >/dev/null; [ $? -eq 1 ] && ok "Exit 1 bei Befunden" \
  || nok "Exit-Code"
./manifestlint manifests/backup.yml >/dev/null && ok "Digest ist sauber" \
  || nok "backup.yml"
./manifestlint -o json manifests | jq -e 'length == 5' >/dev/null \
  && ok "JSON: 5 Befunde" || nok "JSON"
./manifestlint gibt-es-nicht 2>/dev/null; [ $? -eq 2 ] && ok "Exit 2 bei Fehler" \
  || nok "Fehlerpfad"

Erwartet:

✔ vet + Tests
✔ Exit 1 bei Befunden
✔ Digest ist sauber
✔ JSON: 5 Befunde
✔ Exit 2 bei Fehler

Challenge

Neue Regel probe: Jeder Container eines Deployments oder StatefulSets braucht eine readinessProbe. Init-Container sind ausgenommen.

Hinweis: Den Inhalt der Probe musst du nicht verstehen – ein Feld vom Typ any ist nil, wenn der Schlüssel fehlt.

Lösung

In internal/lint/manifest.go den Container erweitern:

type Container struct {
    Name           string `yaml:"name"`
    Image          string `yaml:"image"`
    ReadinessProbe any    `yaml:"readinessProbe"` // nur: vorhanden oder nicht
    Resources      struct { // gofmt -w richtet die Spalten aus

In internal/lint/rules.go vor dem letzten return fs in Check:

    if m.Kind == "Deployment" || m.Kind == "StatefulSet" {
        for _, c := range pod.Containers { // Init-Container brauchen keine
            if c.ReadinessProbe == nil {
                add("probe", "%s: readinessProbe fehlt", c.Name)
            }
        }
    }
gofmt -w . && go build -o manifestlint ./cmd/manifestlint
./manifestlint manifests | grep probe
go test ./... 2>&1 | tail -3
go test ./cmd/manifestlint -update && go test ./...

Erwartet (gekürzt):

manifests/app/web.yaml Deployment/web probe: web: readinessProbe fehlt
FAIL    example.com/manifestlint/cmd/manifestlint   0.145s
ok      example.com/manifestlint/internal/lint  0.273s
FAIL
ok      example.com/manifestlint/cmd/manifestlint   0.151s
ok      example.com/manifestlint/internal/lint  0.180s

Das Golden File schlägt an – genau richtig, das JSON hat sich geändert. Erst nach Prüfung mit -update neu schreiben.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Für echte Policy-Durchsetzung im Cluster: Kyverno, OPA Gatekeeper oder ValidatingAdmissionPolicy (CEL); manifestlint ist der schnelle Check davor in der Pipeline.
  • Etablierte Linter wie kube-linter, kube-score oder Polaris bringen Dutzende Regeln mit – ein eigenes Tool lohnt sich für hausinterne Regeln (Team-Labels, erlaubte Registries).
  • Für SARIF- oder JUnit-Ausgabe reicht ein weiteres -o-Format; GitLab und GitHub zeigen Befunde dann direkt im Merge Request.
  • Große Monorepos: Dateien parallel prüfen (Tag 8) und nur geänderte Dateien aus git diff --name-only übergeben.
  • Ausnahmen brauchen einen Prozess: Annotation mit Begründung und Ablaufdatum statt stillem Abschalten einer Regel.