Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Eine Richtlinie über die gerenderte Ausgabe: eine Hausregel, vier Ziele, zwei Engines

Eine Hausregel, an der Rolle render-verdict angebunden, beurteilt die Dateien, die ein Build für vier Ziele schreibt, und weist einen auf jedem eingeschleusten Verstoß zurück. Die Regel hat zwei Klauseln:

Jedes Container-Image nennt eine feste Version — ein Tag außer latest oder einen Digest. Jede Datenbankinstanz speichert ihre Daten verschlüsselt.

Dieser Workspace baut ein Aggregate für vier Ziele — Kubernetes über Helm, Docker Compose, Terraform und CloudFormation. Die Rolle render-verdict beurteilt die Dateien, die ein Build schreibt, nachdem jedes Ziel sie gerendert hat, und die Regel liest die eigene Ausgabestruktur jedes Ziels: die Images in Kubernetes-Objekten und in einer Compose-Datei, die RDS-Instanz in einer Terraform-Datei und in einem CloudFormation-Template. Jedes Ziel hat ein Release, das besteht, und ein Release mit einem eingeschleusten Verstoß, das die Regel zurückweist.

Die Regel ist zweimal geschrieben, einmal für jede in die CLI kompilierte Richtlinien-Engine — Rego und CEL —, und die beiden Kopien stimmen bei jedem Build hier überein. Ein Skript neben den Releases baut alle sechzehn Kombinationen und prüft jedes Ergebnis.

aggrega build

Ihre Policy

in den Compiler eingebunden

bestanden

Dateien geschrieben

bereit zur Überprüfung und Bereitstellung

nicht bestanden

Build gestoppt

policy plugin "rego" rejected the build: terraform/modules/db/main.tf: the RDS instance db stores its data unencrypted

Eine Policy kann einen Build stoppen und sagen, was zu beheben ist. Sie ändert nie Ihre Dateien, damit sie bestehen.

Was es baut

InstanzKatalog-Componentwas es hier ist
dbcore/datastore/postgresdie Bestelldatenbank
reportcore/compute/taskein Report-Job, der db liest und von Hand gestartet wird: Er trägt core/manual-trigger, daher startet kein Lauf, wenn das Release bereitgestellt wird

report liest Adresse, Port und Namen der Datenbank über seine Verbindung database, als DB_HOST, DB_PORT und DB_NAME. Das Aggregate ist für jeden Build dieselbe Datei; jedes Release nennt das Manifest, das das Ziel wählt:

Manifestdbreport
manifest-helm.yamlhelm/postgres, ein StatefulSethelm/task, ein suspendiert gehaltener CronJob
manifest-compose.yamlcompose/postgres, ein Servicecompose/task, ein Service hinter einem Profil
manifest-terraform.yamlterraform/postgres-rds, eine RDS-Instanzterraform/task-ecs, eine Amazon-ECS-Task-Definition
manifest-cloudformation.yamlcloudformation/postgres-rds, eine RDS-Instanzcloudformation/task-ecs, eine Amazon-ECS-Task-Definition

Jedes Recipe hier rendert allein aus dem Katalog: Die Kubernetes-Datenbank wird synthetisiert statt als Chart abgerufen, der Inhalt der Terraform-Datenbank wird von ihrem Recipe geschrieben, und das Modul des Terraform-Tasks liegt neben seinem Recipe. Daher läuft jeder Build offline.

Die acht Releases

ReleaseZielwas die Regel findetder Build
release-helm.yamlKubernetesreport führt registry.example.com/orders-report:1.4.2 ausschließt ab
release-helm-unpinned.yamlKubernetesreport führt dasselbe Image mit dem Tag latest ausbricht ab
release-compose.yamlDocker Composereport führt registry.example.com/orders-report:1.4.2 ausschließt ab
release-compose-unpinned.yamlDocker Composereport führt das Image ohne Tag ausbricht ab
release-terraform.yamlTerraformdie Instanz ist mit dem Schlüssel verschlüsselt, den das Release nenntschließt ab
release-terraform-unencrypted.yamlTerraformdas Release nennt keinen Schlüssel, daher ist die Instanz nicht verschlüsseltbricht ab
release-cloudformation.yamlCloudFormationdas Release schaltet StorageEncrypted einschließt ab
release-cloudformation-unencrypted.yamlCloudFormationdas Release lässt es ausgeschaltetbricht ab

Das Image gehört dem Release: core/compute/task paketiert keine Software, daher nennt das Release unter infra.image das Image, das ein Lauf ausführt, einschließlich Tag. Auf den beiden AWS-Zielen gehört auch die Verschlüsselung der Datenbank dem Release. Das Terraform-Recipe liest infra.overrides.kms_key_id und rendert, wenn es gesetzt ist, storage_encrypted = true neben dem Schlüssel; das CloudFormation-Recipe liest infra.overrides.StorageEncrypted und KmsKeyId unter den eigenen Namen der Ressourceneigenschaften. Ein Release, das keines von beiden setzt, rendert eine Instanz ganz ohne Verschlüsselungsattribut, und genau das tun die Releases mit eingeschleustem Verstoß.

Die Kubernetes- und die Compose-Datenbank führen das Image postgres:16 aus, ein festes Tag, daher beurteilt die Regel sie und lässt sie in jedem Release bestehen.

Die Regel anbinden

.aggrega-config.yaml nennt den Hub als seine Registry und kein Katalogverzeichnis sowie keine Governance-Anbindung. Die Regel wird durch die Datei angebunden, die ein Build mit --config benennt: governance-rego.yaml für die Rego-Engine, governance-cel.yaml für die CEL-Engine. Die Rego-Datei lautet:

plugins:
governance:
- uri: governance/rego:0.9.0
role: render-verdict
with:
sources:
- policies/house-rule.rego

--config benennt die globale Konfigurationsdatei für diesen Lauf, anstelle derjenigen, die die Maschine sonst lesen würde, und die .aggrega-config.yaml dieses Workspace legt sich weiterhin darüber. Eine Liste plugins.governance in der Workspace-Datei würde die der benannten Datei ersetzen, weshalb die Workspace-Datei keine deklariert. 0.9.0 ist die Version der Plugin-Entität jeder Engine im Katalog der Standardbibliothek. Beide Engines sind in die CLI kompiliert — aggrega plugin list führt governance/rego und governance/cel unter den eingebetteten integrierten Plugins auf —, daher ruft kein Build hier ein Plugin ab.

Was eine render-verdict-Richtlinie liest

Eine Richtlinie bei render-verdict liest die Dateien, die der Build schreibt, unter input.artifacts, ein Eintrag pro Datei, nach Pfad sortiert. Jeder trägt:

  • path — der Pfad der Datei unter dist/, etwa terraform/modules/db/main.tf;
  • content — der Text der Datei, wie geschrieben;
  • format — das Format, das der Provider des Ziels für die Datei deklariert hat: yaml für die Compose-Datei, json für das CloudFormation-Template, hcl für jede Terraform-Datei, einschließlich des Inhalts der Datenbank, den ihr Recipe schreibt. Wo nichts eines deklariert hat, ist es der leere String, wie bei den Kubernetes-Dateien hier;
  • documents — der Inhalt der Datei, in eine Struktur geparst, als Liste von Dokumenten: eines für jede Datei hier;
  • parse_error — nur bei einer Datei vorhanden, die nicht geparst werden konnte, anstelle von documents.

Neben den Dateien enthält input.sources die eigene Richtliniendatei der Anbindung und input.settings ihre Einstellungen — hier das leere Objekt, da diese Anbindung keine deklariert.

aggrega build --release <release> --dry-run --policy-input <dir> schreibt die Payload, die jede Rolle erhält, nach <dir> und schreibt sonst nichts. Bei render-verdict ist diese Datei das, was die Engine erhält, und nicht das, was die Richtlinie liest: Jede Datei darin trägt ihren path und content und das format, das ihr Provider deklariert hat, und die Engine parst die documents aus dem Inhalt, sobald sie die Payload erhält. Die Datei listet also die Dateien auf, die einer Regel gezeigt werden, nicht aber deren Dokumente. Nachdem ein Build von release-terraform.yaml seine Lockfile gefüllt hat:

Terminal window
aggrega build --release release-terraform.yaml --config governance-rego.yaml --dry-run --policy-input payloads
jq -c '[.artifacts[].path]' payloads/render-verdict.json
# ["terraform/aggrega.modules.tf","terraform/modules/db/main.tf","terraform/modules/report/aggrega.provenance.tf","terraform/modules/report/main.tf","terraform/modules/report/variables.tf"]

Ein Pfad, den eine Regel innerhalb von documents liest, wird in einem Build geprüft, wo die Engine sie geparst hat. Keine Datei, die diese Recipes schreiben, scheitert beim Parsen, daher trägt keine Datei hier parse_error. Jede Klausel dieser Regel liest documents, daher würde eine Datei, die sich nicht parsen ließ, sie ungeprüft bestehen; eine Regel, die das nicht zulassen darf, fügt eine Klausel hinzu, die eine Datei mit parse_error zurückweist.

Wie jede Klausel die Struktur ihres Ziels liest

Jede Klausel nennt die Struktur, die sie liest, und eine Datei einer anderen Struktur trägt nicht, was die Klausel nennt: In Rego ist der Pfad undefiniert, und die Klausel gilt nicht. So läuft eine Regel über die Ausgabe jedes Ziels, und jede Klausel findet nur ihre eigene.

Compose schreibt eine Datei, deren Dokument jeden Service unter services nach Namen schlüsselt:

deny contains msg if {
some artifact in input.artifacts
some doc in artifact.documents
some name, service in doc.services
unpinned(service.image)
msg := sprintf("%v: service %v runs %v, an image with no tag or the tag latest", [artifact.path, name, service.image])
}

Kubernetes-Objekte tragen ihre Container in einem Pod-Template, das ein CronJob eine Ebene tiefer hält als die anderen Arbeitslasten, unter spec.jobTemplate.spec:

pod_template(doc) := doc.spec.jobTemplate.spec.template if doc.kind == "CronJob"
pod_template(doc) := doc.spec.template if doc.kind != "CronJob"

Terraform verschachtelt in nativem HCL einen Block unter seinem Typ und dann unter jedem seiner Labels, und das letzte Label hält eine Liste von Blöcken, weil Blöcke mit gleichem Typ und gleichen Labels in einer Liste zusammengefasst werden. Daher liegen die Attribute einer Instanz einen Index unter ihrem Namen, und die Klausel durchläuft die Liste:

deny contains msg if {
some artifact in input.artifacts
native_hcl(artifact)
some doc in artifact.documents
some name, blocks in doc.resource.aws_db_instance
some block in blocks
not block.storage_encrypted == true
msg := sprintf("%v: the RDS instance %v stores its data unencrypted", [artifact.path, name])
}

Die Liste ist hier wichtiger als bei einer Regel, die nach einem Wert sucht, weil diese Klausel bei einem Fehlen zurückweist. Für einen einzelnen Block geschrieben — some name, block in doc.resource.aws_db_instance — ist block die Liste, block.storage_encrypted ist darauf undefiniert, und not gilt für alles Undefinierte: Die Klausel weist auch release-terraform.yaml zurück, dessen Instanz verschlüsselt ist, mit derselben Meldung wie das Release mit eingeschleustem Verstoß.

Eine Datei .tf.json wird so gelesen, wie ihr Recipe sie geschrieben hat, wobei der Name den Block selbst hält, daher liest eine für eine Form geschriebene Regel die andere nicht. Deshalb liest die Klausel zuerst format: native_hcl nimmt eine Datei, deren Format hcl ist oder deren Format leer ist und deren Name auf .tf endet — eine Datei, für die kein Provider ein Format deklariert hat, wird anhand ihres Namens geparst, daher erkennt auch die Regel sie an ihrem Namen, statt sie zu übergehen. Jede hier gebaute Terraform-Datei ist als hcl deklariert, daher wird hier keine Datei an ihrem Namen erkannt. Diese Recipes schreiben keine Datei .tf.json, daher liest die Regel keine andere Form. Was die Payload jeder Rolle offenlegt stellt beide Formen dar.

CloudFormation schreibt ein Template, dessen Ressourcen unter Resources nach logischer ID geschlüsselt sind, jede mit ihrem Type und ihren Properties:

deny contains msg if {
some artifact in input.artifacts
some doc in artifact.documents
some id, resource in doc.Resources
resource.Type == "AWS::RDS::DBInstance"
not resource.Properties.StorageEncrypted == true
msg := sprintf("%v: the RDS instance %v stores its data unencrypted", [artifact.path, id])
}

Eine Instanz ohne die Eigenschaft StorageEncrypted oder mit ihr auf einen anderen Wert als true gesetzt wird zurückgewiesen: not … == true gilt für beides.

Warum die CEL-Regel anders geschrieben ist

policies/house-rule.cel formuliert dieselben zwei Klauseln und kommt bei jedem Build hier zum selben Verdikt. Die Datei ist an drei Stellen anders geschrieben, jeweils aus einem Grund, der bei der Engine liegt.

Sie prüft jeden Schlüssel, bevor sie ihn liest. Einen Schlüssel zu lesen, den ein Wert nicht trägt, ist in CEL ein Auswertungsfehler statt eines undefinierten Pfads, und ein Fehler bricht den Build ab. Den Dateien jedes Ziels fehlen Schlüssel, die die eines anderen tragen — ein Kubernetes-Objekt hat kein services, eine Compose-Datei kein kind —, daher prüft jede Klausel die Schlüssel, die sie liest, zuerst mit has():

// Docker Compose: a service whose image names no fixed version.
input.artifacts
.filter(a, has(a.documents) && a.documents.exists(d,
has(d.services) && d.services.exists(s,
has(d.services[s].image)
[… omitted: the image test, and the rest of the clause]

Ohne die Prüfung has(d.services) bricht aggrega build --release release-helm.yaml --config governance-cel.yaml --auto-pull ab, welche Images die Kubernetes-Objekte auch ausführen, endet mit 1 und schreibt kein dist/, und die Zeile, die den Fehler meldet, nennt die Richtliniendatei und den Schlüssel:

render-verdict: plugin "governance/cel:0.9.0": call "verdict_render": wasm: plugin "cel" call to verdict_render: policy source "house-rule.cel" could not be evaluated: No such key: services

Sie meldet ein beanstandetes Element pro Datei. Ein Entscheidungsschlüssel sammelt Meldungen, und ein CEL-Ausdruck hat keine Möglichkeit, die Listen, die er pro Datei aufbaut, zu einer Liste zusammenzuführen. Daher meldet jede CEL-Klausel in jeder Datei ein beanstandetes Element: den ersten Container eines Pod-Templates oder, unter den Services, Instanzen und Ressourcen, die eine Datei nach Namen schlüsselt, dasjenige, dessen Name in der Sortierung zuerst kommt. Eine Comprehension durchläuft eine Map in keiner festen Reihenfolge, daher hält die Auswahl nach Namen die Meldung von einem Build zum nächsten gleich. Die Rego-Regel meldet jedes beanstandete Element. Mit zwei nicht fixierten Services in einer Compose-Datei bricht die Rego-Engine mit zwei Meldungen ab und die CEL-Engine mit einer, für den Service, dessen Name in der Sortierung zuerst kommt; mit einem, wie in jedem Release hier, brechen beide mit derselben Meldung ab.

Sie wiederholt sich. CEL bietet keine Möglichkeit, einen Teilausdruck zu benennen, daher wird ein zweimal verwendeter Test zweimal geschrieben, und der Image-Test wird in jeder Klausel ausgeschrieben, statt aufgerufen zu werden, wie es mit unpinned in Rego geschieht.

Die beiden Dateien sind ein bewusstes Beinahe-Duplikat, jede eigenständig aus der obigen Regel geschrieben, statt eine aus der anderen zu generieren, damit ein Build, bei dem die Engines uneins sind, die Uneinigkeit zeigt.

Ein Verdikt ändert nie die Ausgabe

Eine Richtlinie bei render-verdict nimmt den Build an oder weist ihn zurück. Sie erhält die Dateien, die der Build geschrieben hat, und gibt Verdikte zurück; nichts, was sie zurückgibt, wird auf sie angewendet. Daher baut ein Kontroll-Release dieselben Dateien, Byte für Byte, mit angebundener Regel und ohne sie, und check.sh vergleicht die beiden Bäume bei jedem Lauf. Ein zurückgewiesener Build schreibt überhaupt kein dist/. Um eine Zurückweisung zu beheben, ändert sich das Release — ein fixiertes Tag, ein Verschlüsselungsschlüssel —, und der nächste Build wird erneut beurteilt.

Das Beispiel generieren

Sie können dieses Beispiel mit den folgenden Befehlen bauen oder es von Ihrem KI-Assistenten für Sie bauen lassen.

Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:

Terminal window
aggrega scaffold --example policy-render-verdict

Danach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner:

Terminal window
cd policy-render-verdict

Build

Terminal window
aggrega build --release release-terraform.yaml --config governance-rego.yaml --auto-pull
aggrega build --release release-terraform-unencrypted.yaml --config governance-rego.yaml --auto-pull # halts; exits 1

Tauschen Sie governance-rego.yaml gegen governance-cel.yaml, um dieselbe Regel auf der CEL-Engine auszuführen, und terraform im Dateinamen des Release gegen helm, compose oder cloudformation, mit ihren Releases mit eingeschleustem Verstoß release-helm-unpinned.yaml, release-compose-unpinned.yaml und release-cloudformation-unencrypted.yaml.

Der Katalog der Standardbibliothek liefert hier jede Component, jedes Recipe, Feature und FeatureRecipe und führt die Plugin-Entitäten beider Engines. Sie werden aus hub.aggrega.ai aufgelöst, der Standard-Registry, die .aggrega-config.yaml nennt. Mit einem Checkout des Katalogs (wo Sie einen erhalten), der mit --catalog benannt wird, wird nichts aus einer Registry abgerufen, daher laufen die Builds offline. --auto-pull füllt die Lockfile jedes Release während des Builds; Lockfiles und die gerenderte Ausgabe werden erzeugt, nicht mitgeliefert.

Das Terraform-Kontroll-Release wird abgeschlossen. Das Release mit eingeschleustem Verstoß bricht ab:

[… omitted: the lines printed while the lockfile is resolved, which carry the refusal below once more and say the render that discovers external inputs could not finish]
[POLICY_ERROR E0005]
policy plugin "rego" rejected the build: terraform/modules/db/main.tf: the RDS instance db stores its data unencrypted
caused by: policy violation

Jede Meldung nennt die Datei, die die Regel beurteilt hat, als ihren Pfad unter dist/, und das beanstandete Element darin. Die anderen Releases mit eingeschleustem Verstoß brechen auf dieselbe Weise ab:

policy plugin "rego" rejected the build: helm/report-cronjob.yaml: container main runs registry.example.com/orders-report:latest, an image with no tag or the tag latest
policy plugin "cel" rejected the build: compose/docker-compose.yaml: service report runs registry.example.com/orders-report, an image with no tag or the tag latest
policy plugin "cel" rejected the build: cloudformation/cloudformation-stack.json: the RDS instance Db stores its data unencrypted

Jede Zeile ist diejenige nach [POLICY_ERROR E0005] in der Ausgabe ihres Builds, ab dem linken Rand gezeigt. Die erste stammt von der Rego-Engine und die anderen beiden von der CEL-Engine, jeweils mit dem Namen der Engine, die sie gemeldet hat; die andere Engine gibt dieselbe Meldung unter ihrem eigenen Namen aus.

Mit einem KI-Assistenten

Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie ihm diesen Prompt ein.

Verwenden Sie ausschließlich die Aggrega-Tools und legen Sie selbst keinen Ordner an. Wenn der Workspace-Ordner noch keinen Ordner `policy-render-verdict` enthält, rufen Sie das Tool `scaffold` einmal auf, mit `example` auf `policy-render-verdict` gesetzt und ohne `dir`: Es schreibt das Beispiel in einen neuen Ordner `policy-render-verdict`. Rufen Sie dann das Tool `cli-build`, das `aggrega build` ausführt und dessen Flag `--config` annimmt, einmal für jedes Release auf, in dieser Reihenfolge — `release-terraform.yaml` und `release-terraform-unencrypted.yaml` — jedes Mal mit `workspace_root` auf `policy-render-verdict`, `release` auf die jeweilige Datei, `auto_pull` auf true und `config` auf `governance-rego.yaml` gesetzt. Der zweite Build soll abgelehnt werden; lesen Sie mir also die Ablehnung vor. Nennen Sie mir die Dateien, die der erste Build geschrieben hat; sie liegen unter `policy-render-verdict/dist/`.

Jeden Build prüfen

Diese Selbstprüfung läuft in einem Checkout des Dokumentations-Repositorys, das das gemeinsame Build-Hilfsskript enthält, das sie verwendet; eine von aggrega scaffold --example geschriebene Kopie enthält dieses Hilfsskript nicht.

Terminal window
./check.sh

check.sh baut jedes Kontroll-Release einmal ohne angebundene Richtlinie, als Referenz, und dann alle acht Releases unter jeder Engine, über den Build-Release-Helfer. Ein Kontroll-Release muss abschließen und Byte für Byte dieselben Dateien schreiben wie seine Referenz; ein Release mit eingeschleustem Verstoß muss mit E0005 und der für es erwarteten Meldung abbrechen, ohne eine weitere Zurückweisung daneben, und darf kein dist/ schreiben. Für beide Engines gilt dieselbe Meldung. Es gibt eine Zeile pro Build aus und endet mit 1, wenn ein Ergebnis abweicht, wobei es die Ausgabe dieses Builds ausgibt:

ENGINE RELEASE EXIT EXPECTED VERDICT
--------------------------------------------------------------------------------------------------------------
none release-helm.yaml 0 reference OK
none release-compose.yaml 0 reference OK
none release-terraform.yaml 0 reference OK
none release-cloudformation.yaml 0 reference OK
rego release-helm.yaml 0 pass OK: completed, byte-identical to the build with no policy
rego release-helm-unpinned.yaml 1 halt OK: E0005, the expected sentence
rego release-compose.yaml 0 pass OK: completed, byte-identical to the build with no policy
rego release-compose-unpinned.yaml 1 halt OK: E0005, the expected sentence
rego release-terraform.yaml 0 pass OK: completed, byte-identical to the build with no policy
rego release-terraform-unencrypted.yaml 1 halt OK: E0005, the expected sentence
rego release-cloudformation.yaml 0 pass OK: completed, byte-identical to the build with no policy
rego release-cloudformation-unencrypted.yaml 1 halt OK: E0005, the expected sentence
cel release-helm.yaml 0 pass OK: completed, byte-identical to the build with no policy
cel release-helm-unpinned.yaml 1 halt OK: E0005, the expected sentence
cel release-compose.yaml 0 pass OK: completed, byte-identical to the build with no policy
cel release-compose-unpinned.yaml 1 halt OK: E0005, the expected sentence
cel release-terraform.yaml 0 pass OK: completed, byte-identical to the build with no policy
cel release-terraform-unencrypted.yaml 1 halt OK: E0005, the expected sentence
cel release-cloudformation.yaml 0 pass OK: completed, byte-identical to the build with no policy
cel release-cloudformation-unencrypted.yaml 1 halt OK: E0005, the expected sentence
check: every build ended as expected.

Es verwendet die Binärdatei, die ./build-release.sh auflöst, daher wählt AGGREGA_BIN sie aus, und Argumente nach -- erreichen jeden Build. Es verweigert den Start, solange ein dist/ in diesem Verzeichnis liegt, weil es den Baum jedes Builds zum Vergleichen wegverschiebt, und es hinterlässt keinen; die Builds füllen die Lockfiles dieses Verzeichnisses, wie es jeder Build tut. Sein Exit-Status ist das gesamte Urteil.

Wo der Compiler nicht interpretiert

Der Compiler rendert die Dateien jedes Ziels, übergibt sie der angebundenen Engine als Text mit dem Format, das ihr Provider deklariert hat, und handelt nach dem Schweregrad, den jedes Verdikt trägt. Er weiß nicht, was ein Image-Tag ist, dass sich latest verschiebt oder dass eine RDS-Instanz verschlüsselt sein sollte: Diese Bedeutungen gehören der Regel. Zu den Rollen, den Payloads und den Entscheidungsschlüsseln siehe den Governance-Socket.

Dateien

  • aggregate.yaml — die Datenbank und der damit verdrahtete Report-Job.
  • manifest-helm.yaml, manifest-compose.yaml, manifest-terraform.yaml, manifest-cloudformation.yaml — binden jeden Komponententyp und das Feature für den manuellen Auslöser an ihre Recipes auf einem Ziel.
  • release-<target>.yaml, release-<target>-unpinned.yaml, release-<target>-unencrypted.yaml — ein Kontroll-Release und ein eingeschleuster Verstoß pro Ziel.
  • .aggrega-config.yaml — die Standard-Registry; keine Governance-Anbindung.
  • governance-rego.yaml, governance-cel.yaml — die über jede Engine an render-verdict angebundene Regel, jede mit --config benannt.
  • policies/house-rule.rego, policies/house-rule.cel — die Regel, einmal pro Engine.
  • build-release.sh — baut ein Release und gibt dabei den entsprechenden aggrega build-Befehl aus.
  • check.sh — führt die zwanzig Builds aus und prüft jedes Ergebnis.