$ cat <<EOF > kubesec-test.yaml
apiVersion: v1
kind: Pod
metadata:
  name: kubesec-demo
spec:
  containers:
  - name: kubesec-demo
    image: gcr.io/google-samples/node-hello:1.0
    securityContext:
      readOnlyRootFilesystem: true
EOF

# Mit dem lokalen Binary
kubesec scan kubesec-test.yaml

# Oder mit Docker
docker run -i kubesec/kubesec:v2 scan /dev/stdin < kubesec-test.yaml

# Mit dem lokalen Binary und einer menschenlesbaren Tabellenausgabe
kubesec scan kubesec-test.yaml --format table

$ go install github.com/controlplaneio/kubesec/v2@latest

$ GO111MODULE="on" go get github.com/controlplaneio/kubesec/v2

# Eine bestimmte lokale YAML-Datei scannen
kubesec scan ./deployment.yaml

# Aus der Standardeingabe scannen (JSON oder YAML)
cat file.json | kubesec scan -

# Ein gerendertes Helm-Chart scannen
helm template -f values.yaml ./chart | kubesec scan /dev/stdin

# Mehrere YAML-Dokumente scannen, getrennt durch '---'
{ cat test/asset/multi.yml; echo "---"; cat test/asset/critical.yml; } | kubesec scan -

# Eine Datei über Docker mit der Standardeingabe scannen
docker run -i kubesec/kubesec:v2 scan /dev/stdin < kubesec-test.yaml

# JSON-Array-Ausgabe (Standardverhalten)
kubesec scan ./deployment.yaml --format json

# Menschenlesbare Tabellenausgabe
kubesec scan ./deployment.yaml --format table

# Ein benutzerdefiniertes Template für die Ausgabe verwenden
kubesec scan ./deployment.yaml --format template --template report-template.tmpl

# Eine Regel
kubesec scan --rules CapSysAdmin kubesec-test.yaml

# Mehrere Regeln
kubesec scan --rules RunAsNonRoot,SeccompAny,ApparmorAny kubesec-test.yaml

[
  {
    "object": "Pod/security-context-demo.default",
    "valid": true,
    "message": "Failed with a score of -30 points",
    "score": -30,
    "scoring": {
      "critical": [
        {
          "selector": "containers[] .securityContext .capabilities .add == SYS_ADMIN",
          "reason": "CAP_SYS_ADMIN is the most privileged capability and should always be avoided",
          "points": -30
        }
      ],
      "advise": [
        {
          "selector": "containers[] .securityContext .runAsNonRoot == true",
          "reason": "Force the running image to run as a non-root user to ensure least privilege",
          "points": 1
        },
        {
          // ...
        }
      ]
    }
  }
]

# Alle Scan-Regeln mit ihren zugehörigen Punktzahlen anzeigen
kubesec print-rules

# Alle Scan-Regeln mit ihren zugehörigen Punktzahlen als Tabelle anzeigen
kubesec print-rules --format table

[
  {
    "id": "AllowPrivilegeEscalation",
    "selector": "containers[] .securityContext .allowPrivilegeEscalation == true",
    "reason": "Ensure a non-root process can not gain more privileges",
    "kinds": [
      "Pod",
      "Deployment",
      "StatefulSet",
      "DaemonSet"
    ],
    "points": -7,
    "advise": 0
  },
...
]

# Verwendet das neueste Schema von upstream
# Das Schema wird abgerufen von: https://raw.githubusercontent.com/yannh/kubernetes-json-schema/master/master-standalone-strict/pod-v1.json
kubesec scan ./pod.yaml

# Eine bestimmte Schema-Version von upstream verwenden (Format x.y.z ohne v-Präfix)
# Das Schema wird abgerufen von: https://raw.githubusercontent.com/yannh/kubernetes-json-schema/master/v1.25.3-standalone-strict/pod-v1.json
kubesec scan ./pod.yaml --kubernetes-version 1.25.3

# Eine bestimmte Schema-Version in einer abgeschotteten Umgebung über HTTP verwenden
# Das Schema wird abgerufen von: `https://host.server/v<version>-standalone-strict/pod-v1.json`
kubesec scan ./deployment.yaml --kubernetes-version <version> --schema-location https://host.server

# Eine bestimmte Schema-Version in einer abgeschotteten Umgebung mit lokalen Dateien verwenden
# Das Schema wird gelesen von: `/opt/schemas/v<version>-standalone-strict/pod-v1.json`
kubesec scan ./deployment.yaml --kubernetes-version <version> --schema-location /opt/schemas

# HTTP-Server im Hintergrund auf Port 8080 starten
kubesec http 8080 &

# Eine Datei per POST an den laufenden Server senden
curl -sSX POST --data-binary @deployment.yaml http://localhost:8080/scan

# Hintergrundserver stoppen, wenn er fertig ist
kill %

# HTTP-Server mit Docker starten
docker run -d -p 8080:8080 kubesec/kubesec:v2 http 8080

# Eine Datei per POST an den laufenden Server senden
curl -sSX POST --data-binary @deployment.yaml http://localhost:8080/scan

# Ein Manifest direkt an die gehostete v2-API übermitteln
curl -sSX POST --data-binary @"deployment.yaml" https://v2.kubesec.io/scan

# Die API-Ausgabe mit jq parsen und einen Exit-Code ungleich Null zurückgeben, wenn der Score <= 10 ist
curl -sSX POST --data-binary @"deployment.yaml" https://v2.kubesec.io/scan | jq --exit-status '.score > 10'

# Den Abfrageparameter "rule" verwenden, um nur bestimmte Regeln zu scannen (mehrere werden unterstützt)
curl -sSX POST --data-binary @test/asset/score-0-cap-sys-admin.yml "http://localhost:8080/scan?rule=SeccompAny&rule=ApparmorAny"

# Eine BASH-Funktion definieren
$ kubesec ()
{
    local FILE="${1:-}";
    [[ ! -e "${FILE}" ]] && {
        echo "kubesec: ${FILE}: No such file" >&2;
        return 1
    };
    curl --silent \
      --compressed \
      --connect-timeout 5 \
      -sSX POST \
      --data-binary=@"${FILE}" \
      https://v2.kubesec.io/scan
}


# Eine Kubernetes-Ressource an v2.kubesec.io/scan senden
$ kubesec ./deployment.yml

# Exit-Code ungleich Null zurückgeben, wenn der Score nicht größer als 10 ist
$ kubesec ./score-9-deployment.yml | jq --exit-status '.score > 10' >/dev/null
# Statuscode 1