Dieses Dokument wurde mithilfe automatisierter maschineller Übersetzungstechnologie übersetzt. Wir bemühen uns um korrekte Übersetzungen, übernehmen jedoch keine Gewähr für die Vollständigkeit, Richtigkeit oder Zuverlässigkeit der übersetzten Inhalte. Im Falle von Abweichungen ist die englische Originalversion maßgebend und stellt den verbindlichen Text dar.

Dies ist eine unveröffentlichte Dokumentation für Admission Controller 1.34-dev.

Validierung mit JSON-Abfragen

Ein früherer Abschnitt zeigt, wie man eine Validierung Richtlinie mit Go-Typen, die Kubernetes-Objekte beschreiben, schreibt.

Es gibt einen anderen Weg, um die Validierungslogik zu schreiben, indem man die relevanten Daten aus dem JSON-Dokument mit Ad-hoc-Abfragen extrahiert.

Dieser "jq-ähnliche" Ansatz kann nützlich sein, wenn die Richtlinie tief in ein Kubernetes-Objekt schauen muss. Es ist besonders hilfreich, wenn man es mit optionalen inneren Objekten zu tun hat.

Dieses Dokument implementiert den früheren Code neu, indem es JSON-Abfragen anstelle des Unmarshalings der JSON-Nutzlast in Go-Typen verwendet.

Die validate Funktion

Sie können die Richtlinie, die Sie gerade erstellt haben, verwenden und ihre validate Funktion ändern, um die Go-Typen, die Kubernetes-Objekte definieren, nicht zu verwenden.

Stattdessen können Sie die gjson Bibliothek verwenden, um Daten aus dem rohen JSON-Objekt zu extrahieren.

Zuerst müssen Sie den Abschnitt zu den Anforderungen ändern. So sollte der Code aussehen:

import (
    "encoding/json"
    "fmt"

    mapset "github.com/deckarep/golang-set/v2"
    kubewarden "github.com/kubewarden/policy-sdk-go"
    kubewarden_protocol "github.com/kubewarden/policy-sdk-go/protocol"
    "github.com/tidwall/gjson"
)

Ändern Sie die validate Funktion, sodass sie wie folgt aussieht:

validate Funktion 
func validate(payload []byte) ([]byte, error) {
    // Create a ValidationRequest instance from the incoming payload
    validationRequest := kubewarden_protocol.ValidationRequest{}
    err := json.Unmarshal(payload, &validationRequest)
    if err != nil {
        return kubewarden.RejectRequest(
            kubewarden.Message(err.Error()),
            kubewarden.Code(400))
    }

    // Create a Settings instance from the ValidationRequest object
    settings, err := NewSettingsFromValidationReq(&validationRequest)
    if err != nil {
        return kubewarden.RejectRequest(
            kubewarden.Message(err.Error()),
            kubewarden.Code(400))
    }

    // Access the **raw** JSON that describes the object
    podJSON := validationRequest.Request.Object

    // NOTE 1
    data := gjson.GetBytes(
        podJSON,
        "metadata.labels")

    var validationErr error
    labels := mapset.NewThreadUnsafeSet[string]()
    data.ForEach(func(key, value gjson.Result) bool {
        // NOTE 2
        label := key.String()
        labels.Add(label)

        // NOTE 3
        validationErr = validateLabel(label, value.String(), &settings)

        // keep iterating if there are no errors
        return validationErr == nil
    })

    // NOTE 4
    if validationErr != nil {
        return kubewarden.RejectRequest(
            kubewarden.Message(validationErr.Error()),
            kubewarden.NoCode)
    }

    // NOTE 5
    for requiredLabel := range settings.ConstrainedLabels {
        if !labels.Contains(requiredLabel) {
            return kubewarden.RejectRequest(
                kubewarden.Message(fmt.Sprintf("Constrained label %s not found inside of Pod", requiredLabel)),
                kubewarden.NoCode)
        }
    }

    return kubewarden.AcceptRequest()
}

Der erste Teil der validate Funktion ist ähnlich wie zuvor. 'HINWEISE' kennzeichnen die Änderungen.

  1. Sie verwenden einen gjson Selektor, um die label Karte zu erhalten, die vom in die Anfrage eingebetteten Objekt bereitgestellt wird.

  2. Sie verwenden einen gjson Helfer, um über die Ergebnisse der Abfrage zu iterieren. Wenn die Abfrage keine Ergebnisse hat, findet die Schleife niemals statt.

  3. Sie verwenden die validateLabel Funktion, um das Label und seinen Wert wie zuvor zu validieren. Sie fügen auch die im Pod gefundenen Labels zu einem zuvor definierten mapset.Set hinzu.

  4. Wenn die Validierung einen Fehler produziert, geben Sie sofort eine Ablehnung der Validierung zurück.

  5. Wie zuvor iterieren Sie über die constrainedLabels, um zu überprüfen, ob alle im Pod angegeben sind. Der Code wurde leicht geändert, um die zuvor gefüllte mapset.Set zu nutzen.

Testen des Validierungscodes

Die Unit-Tests und die End-to-End-Tests benötigen keine Änderungen, Sie können sie wie zuvor ausführen.

make test
go test -v
=== RUN   TestParseValidSettings
--- PASS: TestParseValidSettings (0.00s)
=== RUN   TestParseSettingsWithInvalidRegexp
--- PASS: TestParseSettingsWithInvalidRegexp (0.00s)
=== RUN   TestDetectValidSettings
--- PASS: TestDetectValidSettings (0.00s)
=== RUN   TestDetectNotValidSettingsDueToBrokenRegexp
--- PASS: TestDetectNotValidSettingsDueToBrokenRegexp (0.00s)
=== RUN   TestDetectNotValidSettingsDueToConflictingLabels
--- PASS: TestDetectNotValidSettingsDueToConflictingLabels (0.00s)
=== RUN   TestValidateLabel
--- PASS: TestValidateLabel (0.00s)
PASS
ok      github.com/kubewarden/go-policy-template    0.002s
make e2e-tests
bats e2e.bats
e2e.bats
 ✓ accept when no settings are provided
 ✓ accept because label is satisfying a constraint
 ✓ accept labels are not on deny list
 ✓ reject because label is on deny list
 ✓ reject because label is not satisfying a constraint
 ✓ reject because constrained label is missing
 ✓ fail settings validation because of conflicting labels
 ✓ fail settings validation because of invalid constraint

8 tests, 0 failures

Alle Tests funktionieren wie erwartet.