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/v3in schmale Structs dekodieren – nur die Felder, die du prüfst. - Mehrere Dokumente pro Datei (
---) per Decoder-Schleife bisio.EOF. - Verzeichnisse mit
filepath.WalkDir, stdin überio.Reader– derselbe Code für Datei und Pipe. - Ausgabe mit
encoding/jsonund 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/.cacheErwartet:
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}]
EOFcat > 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}
EOFDer \ 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.mdFortschritt 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)
}
}
}
EOFWarum? 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"
}
EOFgo 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
}
EOFWarum 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
}
EOFgo 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.yamlErwartet (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)
}
}
EOFDas 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)
}
}
EOFgo 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.yamlcat > 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)
}
})
}
}
EOFgo 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
-updateimmergit 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 -cErwartet:
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);
manifestlintist 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.