Gobernanza y cumplimiento
Este capítulo define cómo los equipos de plataforma imponen el cumplimiento corporativo en cada build —mediante el socket de gobernanza, las bases y los esquemas del catálogo, y las convenciones que siguen los autores del catálogo— sin codificar políticas de forma fija en el compilador. Los eventos del ciclo de vida Day-2 son el tema de Ciclos de vida Day-2.
Patrones de gobernanza y cumplimiento empresarial
Un desafío central de la ingeniería de plataformas es imponer la gobernanza corporativa (como el cumplimiento de SOC 2, el seguimiento de centros de coste de FinOps y una asignación estricta de la propiedad) sin contaminar el catálogo de código abierto.
Si Aggrega codificara de forma fija lógica específica de dominio en sus componentes oficiales, dejaría de ser un compilador sin opiniones propias y degeneraría en un framework con opiniones propias. Por el contrario, si el cumplimiento se deja por completo al desarrollador, las etiquetas críticas se escribirán mal, se olvidarán o se eludirán.
Para resolverlo, Aggrega proporciona los mecanismos de sockets Wasm para el cumplimiento, mientras que la empresa dicta la política. Las empresas logran una gobernanza de confianza cero adoptando dos contratos sociales distintos dentro de su ecosistema.
1. «Bring Your Own Baseline» (BYOB) + puerta de validación Wasm
Para los datos estáticos que aporta el desarrollador (como el equipo propietario o la clasificación de datos), las empresas nunca deberían depender directamente del catálogo de código abierto en bruto. En su lugar, el arquitecto de plataforma escribe una base corporativa —los campos que todo componente interno debe llevar, declarados una sola vez en una entrada de SchemaLibrary— y usa un rol de veredicto de gobernanza para imponer su uso.
El contrato del catálogo: La empresa crea una base que exige etiquetas específicas pero no aprovisiona ninguna infraestructura.
apiVersion: aggrega.ai/v1beta1kind: SchemaLibrarymetadata: name: CorporateBaseline version: 1.0.0spec: schemas: Ownership: type: object properties: owner: { type: string } cost_center: { type: string } # The developer MUST provide these, or the schema validator halts the build required: [owner, cost_center]Cada componente interno (p. ej., acme/datastore/postgres) hace referencia a la entrada desde su propio schema: y añade los valores que le son propios, de modo que los campos compartidos y los campos propios del componente se validan juntos:
apiVersion: aggrega.ai/v1beta1kind: Componentmetadata: name: acme/datastore/postgres version: 1.0.0 labels: component.aggrega.ai/type: stateful-serverspec: schema: values: $ref: "CorporateBaseline#/schemas/Ownership" properties: database: { type: string } required: [database]La base es una entrada de biblioteca en lugar de un Component base porque un Component que escribe extends: recibe completo el schema: de su base y no declara valores propios (consulta Herencia y disciplina de publicación).
La salvaguarda de validación Wasm: Para impedir que un desarrollador eluda el catálogo interno y obtenga un componente core/postgres desnudo directamente del hub público, la empresa registra un plugin de validación topológica. Se evalúa durante el análisis estático — después de ensamblar el grafo y antes de renderizar cualquier artefacto —, por lo que ve toda la topología y no un componente a la vez.
# Evaluated by the governance ir-verdict role over the assembled graphpackage acme.governance
import rego.v1
deny contains msg if { some id, _ in input.graph.spec.nodes not input.graph.spec.values_mapping[id].owner msg := sprintf("node %v declares no owner; use a component whose schema references 'CorporateBaseline#/schemas/Ownership'.", [id])}Una decisión que la política recoge bajo su clave de denegación es un rechazo, y la compilación se detiene en ella.
Prohibir las conexiones libres: Un desarrollador puede conectar una arista a través de un socket que el catálogo no declaró — un socket ad hoc (consulta dependency-resolution). Esa apertura es deliberada, y también lo es que el compilador no tenga ninguna opinión al respecto: una organización que quiere que cada conexión pase por un socket declarado por sus arquitectos lo expresa como política en lugar de confiar en el compilador. Cada arista del grafo lleva socket_declaration, cuyo valor es declared o ad-hoc, así que la regla ocupa una línea:
# Evaluated by the governance ir-verdict role over the assembled graphpackage acme.governance
import rego.v1
deny contains msg if { some e in input.graph.spec.edges e.socket_declaration == "ad-hoc" msg := sprintf("%v connects to %v through the free-form socket %v; declare the socket in the component type's usesSchema.", [e.source, e.target, e.socket])}El valor está siempre presente en cada arista, sea cual sea la forma en que se escribió la arista, de modo que una política nunca tiene que leer un campo ausente como «declared». Y es un eje propio: indica de dónde procede el socket, no quién trazó la arista, así que se combina con origin_feature y origin_release en lugar de solaparse con ellos — una política puede prohibir las conexiones libres y seguir permitiendo que la Release conecte las declaradas.
Gobernanza empresarial centralizada (evaluar la realidad completa): Los mecanismos fuera de banda (como CODEOWNERS en un repositorio git) revisan los archivos que cambian, no la arquitectura en la que se compilan. Los roles de veredicto de gobernanza juzgan la propia arquitectura. Como el compilador AOT construye el grafo IR aplanando tanto el Aggregate del desarrollador como la Release del operador de plataforma, una política en el rol ir-verdict evalúa la realidad completa antes de que se generen los artefactos físicos, y una en el rol render-verdict evalúa los propios artefactos. Las políticas pueden detener fatalmente la compilación si un desarrollador solicita un Component no aprobado o —leyendo la procedencia aggrega.ai/recipe-uri estampada en cada objeto renderizado— si el Manifest asigna un componente a una Recipe no aprobada.
2. La puerta mutadora Wasm (cumplimiento dinámico)
No se debería obligar a los desarrolladores a escribir manualmente etiquetas de cumplimiento del entorno (p. ej., environment: production o soc2_in_scope: true) en su Aggregate, ya que cambian según el destino de GitOps.
Para los metadatos dinámicos, las empresas utilizan la Mutation Gate — el rol label-transform del socket de gobernanza, que se ejecuta durante la construcción de la topología. Después de expandir el grafo, y antes de que el análisis estático lo evalúe, el compilador ejecuta el plugin Wasm que la empresa adjuntó. Ese plugin lee el entorno de la Release, las etiquetas que los nodos ya declaran y los valores que declara la instancia de cada nodo, y nombra las etiquetas que deben llevar los nodos de la compilación — así los metadatos requeridos llegan al componente sin que el desarrollador los escriba (p. ej., la etiqueta compliance.aggrega.ai/data-class: restricted decidida a partir del entorno de la Release, o datastore.aggrega.ai/engine: vector decidida a partir de las extensiones declaradas de una base de datos). Los valores son de solo lectura: el plugin decide etiquetas y nada más.
Una política en este rol nombra la etiqueta — el nodo, la clave y el valor que toma — en lugar de escribir la instrucción de edición que aplica la compilación. El motivo importa a quien escriba una: la instrucción direcciona una etiqueta por ruta, y una clave de etiqueta de Aggrega contiene habitualmente una /, que es el separador de ruta, de modo que una ruta escrita a mano direccionaría una ubicación anidada en lugar de una sola etiqueta. La compilación direcciona la etiqueta que nombra la decisión, y la proyección de los nodos que recibe este rol los sitúa un nivel menos profundo que un veredicto sobre el grafo completo.
# Evaluated by the governance label-transform role, during topology constructionpackage acme.tagging
import rego.v1
labels contains {"node": id, "key": "acme.com/soc2-scope", "value": "true"} if { input.compilation_context.environment == "production" some id, node in input.graph.nodes node.labels["component.aggrega.ai/type"] == "stateful-server"}Como estas etiquetas se inyectan en memoria en el diccionario de metadatos estándar antes de que comience el renderizado, los plugins de renderizado Wasm pueden leerlas para generar condicionalmente configuraciones físicas específicas — recursos de AWS o Kubernetes reforzados, por ejemplo — a medida que se renderizan los artefactos.
Declarar una regla una sola vez: los adjuntos de gobernanza tienen ámbito de espacio de trabajo. Los dos patrones anteriores se escriben por componente y por Feature, pero el adjunto de gobernanza que los impone no. Un plugin de gobernanza se adjunta en la clave plugins.governance de la configuración del espacio de trabajo, y ese adjunto vincula cada compilación del espacio de trabajo. Por tanto, una regla corporativa se declara en un único lugar: el equipo de plataforma adjunta el plugin una vez, y ningún componente, Aggregate ni Release tiene que adherirse, mencionarlo ni modificarse para que se aplique. Esto es lo que convierte la salvaguarda de validación del patrón 1 en una respuesta completa y no en una convención por proyecto — un desarrollador que elude el catálogo interno y solicita un core/postgres desnudo es evaluado por la misma política adjunta que todos los demás, porque la política es una propiedad del espacio de trabajo y no del componente que eligió.
Una regla del espacio de trabajo rechaza; no reescribe el contrato del desarrollador. El ámbito es universal, y el efecto se limita deliberadamente a un veredicto. Una regla que se aplica en todas partes detiene una compilación que la infringe, indicando qué corregir, y no puede en cambio modificar el componente infractor para que cumpla. Ese límite es lo que mantiene el mecanismo depurable a la escala de todo el parque: una compilación o bien se ajusta a las reglas que declara el espacio de trabajo, o bien se detiene con un mensaje que apunta a la línea escrita, y la salida renderizada nunca contiene una restricción o un recurso que ningún archivo escrito haya pedido. Cuando una empresa sí quiere que el grafo se modifique en lugar de juzgarse, adjunta un rol de transformación — el patrón 2 anterior — y ese cambio se limita a aquello para lo que el operador lo adjuntó, por lo que es un acto explícito del equipo de plataforma y no una reescritura invisible.
La consecuencia práctica para un equipo de plataforma que cierra el círculo del cumplimiento: expresar la forma que debe tener una carga útil como restricciones de esquema sobre una base corporativa, expresar las reglas entre entidades que exige el parque como un rol de veredicto adjunto, y expresar los metadatos derivados que el desarrollador nunca debería escribir como un rol de transformación adjunto. Los tres se declaran una vez y se aplican a cada compilación, y ninguno requiere que el desarrollador sepa que existen.
3. Preservar la inteligencia de dominio (las configuraciones y la seguridad)
Como el compilador de Aggrega es un compilador sin opiniones propias, no posee ningún conocimiento codificado de frameworks de IA, presupuestos de tokens ni particionamiento de memoria. En su lugar, los esquemas genéricos nativos de la nube actúan como un recipiente vacío. En lugar de estar codificada en el núcleo del compilador, la inteligencia de dominio altamente especializada se distribuye por todo el ecosistema extensible de Aggrega. Se encapsula en el catálogo de la plataforma mediante components, features y recipes especializados. Los desarrolladores preservan su intención de aplicación específica en sus bloques values y uses — estrictamente gobernados por las declaraciones schema: del arquitecto (forma compacta o JSON Schema 2020-12 completo) y sus sockets usesSchema —, mientras que la traducción física de esa inteligencia la ejecutan plugins de WebAssembly específicos de cada destino.
A. Modelado de implementaciones específicas de dominio (validadas mediante esquemas divididos)
Los arquitectos de plataforma pueden aprovechar el pipeline de esquemas divididos para modelar cualquier arquitectura compleja, con total independencia del núcleo del compilador:
- Lógica de ejecución opaca (
values): Si una empresa despliega un AI Gateway, el desarrollador configura el comportamiento propio de la pasarela — en la pasarela de IA de la biblioteca estándar, el mapamodelsque publica cada alias que un llamador puede solicitar y el upstream al que se resuelve cada uno. El núcleo del compilador no analiza estos conceptos. Residen de forma segura en la carga útil opacavalues, estrictamente validada por la declaraciónschema:del componente. El compilador simplemente pasa esta carga útil al plugin Wasm para generar la configuración de la pasarela. Los controles que comparten varios productos de pasarela, como una cadena de respaldo, un número de reintentos o la elección entre entradas que publican el mismo alias, son Features adjuntas a la pasarela y no valores sobre ella, cada una realizada para una pasarela en los términos propios de esa pasarela. - Mapeo de dependencias topológicas (
uses): Donde un framework de IA conecta un agente a sus herramientas o a un almacén de datos vectorial, esa conexión determina quién habla con quién, por lo que se declara en el pilaruses; una lista de nombres guardada envalues, comotools_allowedde la biblioteca estándar, es una convención que no traza ninguna arista. El compilador traza estas aristas explícitas literalmente en el grafo IR. Esto permite que los plugins de renderizado Wasm posteriores generen mediante programación las políticas de red y los límites físicos necesarios para proteger las conexiones, sin que el compilador entienda el framework de IA subyacente. - Estructuras de datos complejas (p. ej., CoALA): En lugar de limitarse a una única lista plana de destinos, los arquitectos declaran en
usesSchematantos sockets como necesite una estructura, cada uno con su propio selector y su propiovalueSchemapor arista. Por ejemplo, para implementar el framework CoALA, un arquitecto puede declararsemantic_memory,episodic_memoryyworking_memorycomo sockets distintos, de modo que cada almacén de memoria sea un destino topológico distinto. Los motores de políticas genéricos evalúan estas aristas estructuradas para exigir salvaguardas granulares de control de acceso para cada lóbulo cognitivo distinto.
B. Mecanismos centrales de seguridad e indirección
Aunque la carga útil permanece sin opiniones propias, el esquema genérico impone mecanismos estructurales estrictos que respaldan una generación segura de artefactos:
- El patrón adjunto-no-valor: la convención de la biblioteca estándar es que una credencial se solicite como adjunto, nunca escrita en un bloque
valuesdonde sería un literal en línea que el compilador transporta literalmente. Un adjunto de credencial nombra untypede Feature de credencial (una con la etiquetafeature.aggrega.ai/kind: secret) y usa sus propiosvaluespara describir la consulta a un almacén de secretos. El enrutamiento de credenciales es entonces un enlace tardío independiente de la capacidad, y el núcleo del compilador nunca resuelve ni expone el material — canaliza el puntero que suministró la Recipe de Ops. Se trata de una convención que el catálogo y los esquemas fomentan, no de una comprobación del compilador: el compilador no interpreta qué significa una hoja devalues, así que un autor que incluye el material en línea lo incluye en línea. Lo que el esquema sí garantiza es que la superficie de adjuntos existe y está tipada. - Verificación abstracta de confianza: Como el bloque
valueses ampliamente extensible, los arquitectos pueden exigir directivas abstractas comotls_pinningorequired_signatures: 2(para consenso por quórum). El núcleo del compilador pasa literalmente estos objetos validados por el esquema al grafo IR plano. Un plugin de renderizado Wasm propio puede entonces leer estos valores para generar artefactos para puertas de aprobación Human-in-the-Loop (HITL) a nivel de hardware. Si una aplicación intenta eludir las reglas de consenso, el proxy desplegado físicamente bloquea la ejecución hasta recibir una aprobación por webhook.
C. Seguridad operativa avanzada (spec.interoperability)
Para proteger las cargas de trabajo frágiles de mutaciones de infraestructura en conflicto, el esquema genérico Feature define un control de interoperabilidad:
spec.interoperability.conflictsWith— una lista de las Features que no pueden llegar al mismo componente que esta. El compilador detiene la compilación antes del renderizado cuando los adjuntos con los que termina un componente — reunidos de cada ámbito que lo alcanza: el propio componente, un subsistema o límite que lo contiene, su entrada de componente en la Release y la expansión dirigida por anotaciones — contienen esta Feature y una que ella nombra. Es una comparación entre los nombres que declaró el autor de la Feature y las Features que lleva el componente, sin atribuir significado a ninguno de los dos: la incompatibilidad es el juicio del autor, y el compilador somete la compilación a él. Basta una declaración, los nombres se comparan sean cuales sean sus versiones, y dos Features adjuntas a límites hermanos que no comparten ningún componente nunca se encuentran.
4. Gobernanza de los límites de red (convención de denegación por defecto)
Los desarrolladores no escriben las políticas de red directamente; los límites de red necesarios los traza el grafo de la representación intermedia (IR) del compilador, que contiene cada arista topológica entre los componentes declarados en el Aggregate.
- Límites internos. El compilador traza el grafo IR plano y no restringe nada por sí mismo: sin una política, toda conexión que la red del clúster permita sigue siendo alcanzable. La convención es que una política escrita para un componente permita una conexión solo donde el Aggregate declara una arista para ella, además de lo que nombra la propia asociación de la política, y deniegue cualquier otra conexión en la dirección que la política gobierna.
- La realización de la biblioteca estándar. El catálogo de la biblioteca estándar realiza la convención como dos Features que el operador asocia a un componente en la Release, una para cada dirección de una conexión:
core/caller-allowlistadmite conexiones solo desde los componentes cuyas aristasusesapuntan a él, ycore/egress-allowlistpermite que el componente se conecte solo a los componentes a los que apuntan sus propias aristas y al DNS del clúster. En el destino helm, cada una se realiza mediante una FeatureRecipe que escribe una NetworkPolicy de Kubernetes a partir de las aristas que el compilador le entrega, identificando los pods de cada componente a partir de lo que emitió el propio renderizado de ese componente —los selectores y etiquetas que llevan sus cargas de trabajo, el namespace en el que se emiten y los puertos que declaran sus contenedores—, de modo que ninguna etiqueta ni puerto se repite a mano. Cada una admite además los pods propios del componente y lo que la Release nombra en la asociación: orígenes externos al Aggregate en el lado de entrada y, en el lado de salida, rangos de direcciones para un destino que el clúster no ejecuta, que no renderiza pods que seleccionar y solo se admite por rango, en cualquier puerto. El compilador no puede inspeccionar el clúster, así que cada una detiene la compilación hasta que la Release afirme que el plugin de red del clúster aplica las políticas de red; compose no tiene política de red, y una compilación que asocie cualquiera de las dos allí se detiene. - Ingress público (control de perímetro agnóstico). El ingress público se gobierna mediante las reglas propias de la empresa en un rol de veredicto de gobernanza. Un equipo de seguridad corporativo puede escribir una política que evalúe el tipo de ontología cloud-native de un nodo y rechace la compilación si un desarrollador intenta asociar una funcionalidad
public-ingressa un nodoworkerotask. El compilador no interpreta qué significa «público»; aplica la salida booleana de la compuerta de validación Wasm.
5. Sellado de procedencia en tiempo de compilación
El compilador construye un registro de procedencia durante la compilación, que captura la versión del compilador y las versiones del Aggregate, el Manifest y la Release que compiló —y ninguna marca de tiempo, de modo que el registro nunca rompe una salida idéntica byte a byte. El renderizador helm emite la versión del compilador como la etiqueta aggrega.ai/compiler-version en los manifiestos de Kubernetes generados, y el renderizador helm-chart en los archivos de plantilla que una Recipe añade a un chart, ya que copia sin cambios las plantillas propias del chart; los equipos de seguridad empresariales la usan para identificar qué artefactos renderizados se construyeron con qué versión del compilador —algo importante cuando se descubre una vulnerabilidad en una versión concreta del compilador y hay que auditar los artefactos afectados.
El proveedor compose estampa las mismas claves de procedencia como etiquetas de servicio, el proveedor terraform como un archivo de procedencia en cada módulo que ensambla, y el proveedor cloudformation bajo el Metadata de cada recurso; el registro de procedencia en memoria existe para cada compilación.
6. Metadatos y anotaciones como superficie de extensión
El compilador Go es agnóstico respecto a los conceptos específicos de dominio —frameworks de IA, motores de bases de datos, modismos de Kubernetes— y trabaja solo con operaciones planas a nivel de grafo sobre la IR. Para impulsar el ecosistema sin codificar de forma fija lógica específica de dominio en el binario de Go, la plataforma usa etiquetas y anotaciones de metadatos estándar como superficie de extensión para la inteligencia de dominio.
El compilador no lee ninguna anotación específica de dominio. Agrupa todas las anotaciones aportadas por los desarrolladores y las etiquetas de duck typing en el grafo IR plano y pasa estos metadatos tal cual a los plugins de gobernanza y de renderizado. El ecosistema WebAssembly interpreta los metadatos y ejecuta la lógica necesaria —evaluar políticas de cumplimiento, inyectar etiquetas en artefactos cloud-native o desencadenar la expansión de funcionalidades— con independencia del núcleo del compilador.
Esto mantiene amplia la superficie de extensibilidad (cualquiera puede escribir un plugin Wasm que lea un nuevo prefijo de anotación) a la vez que mantiene estable el núcleo del compilador: no hace falta ninguna versión nueva del núcleo para que el ecosistema añada una nueva anotación específica de dominio.
Qué lee una política sobre una asociación
Un rol de veredicto que evalúa el grafo IR recibe el grafo completo —con cada valor que un autor declaró sensible retenido, como se describe más abajo—, y eso incluye cada asociación que lleva cada nodo, indexada por el nombre que le dio el autor —o, para una asociación escrita en una de las conexiones del nodo, por el alias de la conexión y la ranura unidos por un punto. La razón de llevar el detalle de las asociaciones en lugar de un resumen es que Aggrega no tiene ninguna opinión que resumir: el compilador enruta las asociaciones sin juzgar lo que contienen, así que los hechos que una política necesita para juzgarlas son los hechos que se le entregan a una política.
Por cada asociación, el grafo lleva:
- El tipo de Feature que solicita y la versión del catálogo resuelta para ella. El tipo es la cadena que escribió el autor, tal cual —una referencia con versión fijada y una sin ella son cadenas distintas para un mismo referente, así que una política que compara tipos debe esperar cualquiera de las dos grafías.
- Las etiquetas de catálogo de la Feature asociada, tal cual. Sin filtrar, sin normalizar, en el orden en que las declara la entidad de catálogo. Una política lee exactamente lo que escribió el autor del catálogo, incluidas etiquetas de invención propia del autor de las que Aggrega no tiene ningún conocimiento.
- Las anotaciones de catálogo de la Feature asociada, tal cual. Los
metadata.annotationspropios de la entidad Feature, llevados exactamente en las mismas condiciones que sus etiquetas —sin filtrar, sin normalizar, en el orden declarado por la entidad—, de modo que una clave de anotación en el namespace propio de un autor llega tal como se escribió. Este es un asunto distinto de la anotación que hizo existir en primer lugar una asociación expandida por anotación: el grafo informa ese origen por separado, y una asociación escrita en un bloquefeatures:lleva las anotaciones de la entidad sin informar ningún origen de expansión. - Qué ranura de asociación declarada rellena. Una ranura
featuresSchemase rellena asociando una Feature bajo el nombre de la ranura, así que una asociación que nombra una ranura que declara su Component informa el nombre de esa ranura, y una que no rellena ninguna informafree. Una asociación escrita en una conexión rellena una ranura que declara el socket de la conexión e informa el nombre de esa ranura; como un socket no admite ningún otro nombre, nunca informafree. El valor es el nombre de la ranura y no un indicador, porque qué punto de enlace se rellenó suele ser la mitad más útil de la respuesta. - En qué conexión se escribió, si en alguna. Una asociación escrita en una de las conexiones del componente lleva el socket y el alias de esa conexión, que nombran la arista del grafo en la que se presenta —y, a través de esa arista, el componente al que se presenta. Una asociación del bloque propio del componente no lleva ninguno. La conexión se lleva como dato en lugar de dejar que se deduzca del nombre de la asociación, que contiene el alias y no el socket.
- Si maneja material que un autor declaró sensible, y cuáles de sus claves de entrega llevan ese material. Ambos se derivan de declaraciones —una hoja
sensitiveen el esquema de una Feature, una ranurasensitiveen el Component consumidor, ya sea una que declara para sus propias asociaciones o una en el socket a través del cual se cablea una conexión—, nunca de inspeccionar un valor. - Sus
values, suinfray su mapeo de entrega, además de si la asociación se escribió en un bloquefeatures:o la aportó la expansión guiada por anotaciones —con cada valor que un autor declaró sensible retenido, como describe el párrafo siguiente.
A una política se le dice dónde está el material declarado sensible, y nunca se le entrega el material. Cada hoja que el grafo marca como declarada sensible —en los values o el infra de cualquier asociación, sea cual sea el ámbito o la conexión en que se escribió, en el infra de una asociación de límite, en los values y el infra propios de un nodo y en los values y el infra propios de una conexión— llega a la política como un marcador de clave única, {"aggrega_withheld": "declared"}, en lugar del valor. La clave se conserva, así que una política sigue viendo qué hojas lleva una carga útil; el marcado que nombra esas hojas se conserva, así que una política sigue viendo cuáles de ellas llevan material declarado; y cada hecho enumerado arriba llega como antes, junto con cada valor que ninguna declaración marca. Ninguno de los hechos sobre los que razona una política —qué es una asociación, qué rellena, a qué se presenta, qué dice de ella su entidad de catálogo y por dónde viaja su material secreto— es un valor que un autor pueda declarar sensible, y el material en sí es lo único que una política no necesita para juzgar adónde va. Es la misma retención que aplica la línea de comandos cuando imprime el grafo y que aplica el daemon cuando responde a la solicitud que un editor hace de él. Esas superficies devuelven los valores a una persona que los pide explícitamente; la copia de una política no ofrece tal solicitud. Se aplica solo a la copia de la política: el grafo a partir del cual renderiza la compilación queda intacto, así que no cambia ningún byte renderizado.
Las etiquetas de una asociación vinculan al compilador en un único lugar, y no es una decisión de política: una ranura puede declarar un selector, y un relleno cuyas etiquetas no lo satisfacen detiene la compilación. Más allá de esa compuerta, las etiquetas no dirigen nada —cómo se enruta y se entrega un valor es igual sean cuales sean las etiquetas que lleve una Feature. Así que una política que lee una etiqueta está leyendo metadatos que el compilador transportó sin interpretarlos, no cuestionando una rama dentro de él.
Las anotaciones de catálogo de una Feature no la vinculan en ningún lugar: ningún comportamiento del compilador se ramifica según ellas, y una ranura no declara ninguna restricción sobre ellas como puede hacerlo sobre las etiquetas. Se transportan y nada más.
Reglas que esto permite escribir, ninguna de las cuales establece el compilador por ti:
- Prohibir la asociación libre. Una organización que exige que cada asociación rellene un punto de enlace declarado rechaza cualquier asociación que informe
free. Es la contrapartida de que la superficie de asociación permanezca abierta: la composición es libre por defecto, y un operador que no la quiere libre lo dice. - Rechazar la entrega por valor de material sensible. Aggrega advierte cuando un dato declarado sensible viaja a través de una clave de entrega como literal, y nunca detiene la compilación —la familia de credenciales por valor es deliberada. Un operador que quiere que esa advertencia sea un rechazo lo expresa aquí.
- Decidir por ti mismo qué cuenta como credencial. La biblioteca estándar marca sus Features de credenciales con una etiqueta de familia, y leer esa etiqueta es una forma de razonar sobre ellas. Un predicado más amplio o más estrecho —una etiqueta interna, una regla de nomenclatura, un conjunto de tipos aprobados— está igualmente disponible, porque llegan las etiquetas y no un veredicto sobre ellas.
- Condicionar a lo que tu catálogo registre en sus propios metadatos. Una organización que guarda el estado de revisión, la residencia de los datos o la propiedad como anotaciones en sus entidades Feature puede exigirlas en cada asociación. Una regla basada en una anotación de la que Aggrega nunca ha oído hablar funciona exactamente igual de bien que una basada en una clave que distribuye, porque las anotaciones llegan tal como se escribieron —lo que también significa que una Feature y un Component se juzgan en igualdad de condiciones, cada uno según los metadatos de catálogo que declara su propia entidad.
- Gobernar qué presenta un componente y a quién. Una credencial escrita en una conexión nombra esa conexión, y la arista de la conexión nombra su destino, así que una organización puede rechazar una credencial presentada a un componente fuera de una zona de confianza que marca con una etiqueta propia —un juicio que necesita ambos extremos de la conexión, algo que ningún hecho sobre el componente consumidor por sí solo aporta.
Un rol de veredicto acepta o rechaza; nunca reescribe. La compilación o bien continúa sin cambios o bien se detiene con el mensaje del veredicto, así que una política no puede hacer conforme discretamente un grafo no conforme.
El detalle de las asociaciones llega a una política que evalúa el grafo IR. Una política que evalúa artefactos renderizados recibe esos artefactos y ningún grafo, lo cual es una propiedad de esa entrada y no una restricción aplicada a ella: las dos etapas responden a preguntas distintas, y la topología de las asociaciones no está entre las preguntas que se le pueden hacer a la salida renderizada.
Expresar las reglas de la organización en un lenguaje de políticas
Los patrones anteriores describen lo que hace una asociación de gobernanza; esta sección trata de lo que una empresa escribe para obtenerla. Un equipo de plataforma con cincuenta reglas que enunciar no quiere cincuenta plugins. Quiere sus reglas como contenido —archivos que revisa, versiona y distribuye como cualquier otro artefacto— con un único motor asociado que las evalúe.
Eso es lo que proporciona un motor de lenguaje de políticas asociado al socket, y dos de ellos se incluyen en el compilador exactamente con este propósito: un motor Rego y un motor CEL. Un operador asocia uno, declara los archivos de políticas que debe cargar, y las reglas se ejecutan: sin cadena de herramientas externa, sin nada descargado en tiempo de compilación y sin lógica de políticas en el compilador. La evaluación ocurre dentro del invitado WebAssembly, que es donde reside toda la inteligencia de dominio.
El mismo motor sirve a cada rol de gobernanza, así que una organización cubre toda su superficie con un solo plugin asociado y varias asociaciones de él:
- Juzgar la arquitectura. Asociada sobre el grafo de compilación, una política lee cada nodo, arista y asociación que contiene el compilador, además de las rutas de enrutamiento enumeradas junto a ellos, e informa de lo que debe detener la compilación. Aquí es donde residen un invariante de topología, una regla de autorización entre límites o una regla de flujo de credenciales.
- Juzgar la salida. Asociada sobre los artefactos renderizados, una política lee los archivos que produjo la compilación —como texto, y como documentos analizados donde el formato se analizó antes de la política— e informa sobre el resultado concreto.
- Aportar metadatos derivados. Asociada para dar forma a las etiquetas, una política decide qué etiquetas llevan los nodos de la compilación, a partir del entorno de la Release y de lo que los nodos ya declaran. Este es el mecanismo que describe el patrón 2 anterior, con la regla expresada como contenido de política en lugar de como un plugin hecho a medida.
- Añadir una capacidad que el desarrollador no escribió. Asociada para inyectar anotaciones, una política añade anotaciones a los componentes de la compilación; una anotación bajo una clave para la que el Manifest registra un enlace se expande en una asociación de Feature, así que una regla corporativa puede aportar el envoltorio que un componente necesita en lugar de limitarse a rechazar su ausencia. Una decisión escribe cualquier valor que un operador podría escribir en esa anotación —una cadena, o un objeto de subclaves para un enlace que encamina varias— y la compilación lo lee exactamente como lee el mismo valor escrito en la Release. Solo puede añadir: un valor que eliminaría una anotación o se excluiría de ella se rechaza, y un valor inyectado que la compilación no puede encaminar o que la Feature enlazada no admite se rechaza nombrando el plugin que lo inyectó.
Una regla lee lo que lleva la carga útil e informa de su decisión bajo una clave con nombre:
# Evaluated by a governance verdict role over the assembled graphpackage acme.security
import rego.v1
deny contains msg if { some id, node in input.graph.spec.nodes node.labels["compliance.aggrega.ai/data-class"] == "restricted" not node.labels["acme.com/owner"] msg := sprintf("node %v holds restricted data and declares no owner.", [id])}Una regla que sigue los datos a lo largo del grafo lee las rutas que la carga útil enumera. language-reference/examples/policy-data-class-route/ es una, de principio a fin: detiene una compilación en la que un componente que contiene datos de una clase alcanza un componente de otra clase a lo largo de una ruta sin ninguna Feature desclasificadora asociada en ella, y el mismo Aggregate se completa cuando una Release enruta ese tráfico a través de un gateway que lleva core/data-masking. El compilador lleva la etiqueta de clase como una cadena y no ordena nada —las clases, su orden y las Features que cuentan como desclasificadoras son la configuración de la asociación. La regla está escrita una vez para cada uno de tres motores —los dos compilados en la CLI y OPA detrás del invitado adaptador de referencia—, cada copia por separado, así que una compilación en la que dos motores discrepan muestra la discrepancia.
Se conserva el vocabulario propio de una política. Las severidades sobre las que actúa el socket son un conjunto cerrado, pero los nombres bajo los que una política agrupa sus decisiones pertenecen a la política. Los nombres predeterminados son los convencionales que ya usa un corpus Rego, y un operador cuyas políticas nombran sus decisiones de otra manera declara el mapeo en la configuración de la asociación —de modo que una organización que ya mantiene una biblioteca de políticas adopta el socket sin reescribirla. El mapeo está tipado por el esquema que el plugin declara para su configuración, así que uno mal formado detiene la compilación antes de que se ejecute ninguna política en lugar de enrutar mal un veredicto.
Toda una biblioteca de políticas viaja como una sola asociación. Un conjunto de políticas puede asociarse archivo por archivo, o como un único archivo comprimido que contiene juntos sus archivos de políticas y sus documentos de datos, que el invitado abre. Un archivo comprimido que no se puede leer se informa como tal, nombrando el archivo —nunca como un conjunto de políticas que no llegó a ninguna decisión, porque «la biblioteca era ilegible» nunca debe ser indistinguible de «la biblioteca permitió la compilación».
Una política no evaluable detiene la compilación. Cuando una política no se puede evaluar, la asociación falla y la compilación se detiene con un error que nombra el plugin, deliberadamente distinto de un veredicto que detiene la compilación. Los dos casos no deben confundirse, y ninguno de ellos es una autorización.
La superficie de autoría completa —la carga útil que expone cada rol, las claves de decisión, el mapeo a severidades y cómo se asocia un archivo comprimido— está en language-reference/plugins/policy-socket.md.
Herencia y disciplina de publicación
La herencia mediante extends: es el mecanismo de catálogo que permite a los arquitectos de plataforma construir entidades hijas especializadas sobre líneas base compartidas. Los dos tipos de catálogo se separan en sus pilares de datos. Los esquemas padre e hijo de una Feature se componen en el momento de cargar el workspace, lo que produce un esquema unificado con procedencia por hoja. Un Component que extiende no escribe contenido de pilar: escribe el marcador literal schema: inherited y recibe el bloque schema: de su base exactamente como la base lo escribió, a cualquier profundidad de una cadena.
Eso es lo que zanja la cuestión de gobernanza que plantea una línea base compartida —qué restricciones puede declarar un hijo respecto a su base. Para un Component, la respuesta es estructural y no vigilada: el contrato declarado del hijo simplemente es el de la base, así que un hijo no puede relajar, eliminar ni cambiar el tipo de una restricción de la base, y no se necesita ninguna comprobación en tiempo de publicación para mantener intacta la línea base. Un hijo que legítimamente necesita una regla más estricta que la que declara su base la expresa como una entrada añadida en su bloque assertions:, que se compone junto a las reglas de la base en lugar de sustituirlas.
Lo que sí compone un Component hijo es la estructura: sus ranuras de asociación (featuresSchema), sus sockets de topología (usesSchema), su lista de permitidos de autoinyección (inject) y sus assertions con nombre se fusionan a lo largo de la cadena, y una entrada redeclarada sustituye por completo a la de la base.
Ubicación de las reglas: qué reglas viven en el plugin de políticas y cuáles en el esquema por Component
El plugin de disciplina de publicación es el lugar de las reglas transversales que se aplican a todo el catálogo: reglas de cadena de suministro (p. ej., «toda Recipe debe hacer implements: de un Component que exista en el catálogo»), reglas de cumplimiento corporativas (p. ej., «todo Component con compliance.aggrega.ai/scope: pci-dss debe hacer extends: de la línea base pci corporativa»). Estas reglas abarcan varias entidades, evalúan el workspace como una unidad o aplican convenciones en tiempo de publicación en lugar de en tiempo de compilación.
La declaración schema: por Component / por Feature es el lugar de las restricciones por entidad: tipos, rangos, patrones y enumeraciones por campo; reglas entre campos expresadas en el bloque assertions: dedicado. Estas restricciones son locales a una entidad y viajan con ella a través del catálogo.
La división no es arbitraria. Una regla como «todo campo obligatorio debe estar presente» es una restricción por entidad que corresponde a los arrays required:. Una regla como «toda entidad hija que extiende un padre pci-dss debe declarar una etiqueta de gobernanza a nivel de workspace» es una regla entre entidades que aplica el plugin de políticas. Las dos clases de reglas nunca se solapan porque responden a preguntas distintas: el esquema valida «esta instancia coincide con su contrato»; el plugin de políticas valida «este catálogo cumple las reglas transversales que exige el workspace».
Al escribir una nueva regla de gobernanza, la pregunta de ubicación es: la regla depende solo del contenido de una única entidad (→ esquema o bloque assertions) o depende de la relación entre varias entidades o de la configuración a nivel de workspace (→ plugin de políticas). El patrón del linter Wasm es el mecanismo canónico para el caso transversal; los catálogos empresariales pueden distribuir plugins de políticas personalizados que consumen la misma interfaz de contrato de plugin que el plugin estándar de disciplina de publicación.
Disciplina de prefijos de anotación
El espacio de nombres de las anotaciones lleva una semántica de origen — prefijos distintos señalan públicos distintos y autoridades de gobernanza distintas. Los autores de catálogos, los equipos de plataforma de las empresas y la propia plataforma Aggrega escriben anotaciones en el mismo diccionario plano; es el prefijo lo que mantiene separados los públicos.
| Prefijo | Origen | Público | Mutabilidad |
|---|---|---|---|
aggrega.ai/ (sin subdominio) | Reservado: emitido solo por el compilador de Aggrega | Herramientas internas, sellado de procedencia | No lo puede escribir el usuario; las anotaciones con el prefijo sin subdominio declaradas en contenido del usuario se rechazan en el momento de la publicación |
<sub-domain>.aggrega.ai/ (p. ej., component.aggrega.ai/, feature.aggrega.ai/, compliance.aggrega.ai/) | Convención del catálogo | Arquitectos que escriben entidades del catálogo; plugins de políticas Wasm que consumen las etiquetas | Los editores del catálogo escriben; los consumidores leen |
<enterprise-domain>/ (p. ej., acme.com/, my-org.io/) | Capa empresarial | Equipos de plataforma de las empresas; plugins Wasm empresariales | Los autores de la empresa escriben; el compilador de la plataforma las ignora como metadatos opacos |
<community-domain>/ (p. ej., cncf.io/, kubernetes.io/) | Ecosistema externo | Herramientas entre ecosistemas que leen etiquetas conocidas | Gobernado por la comunidad |
El prefijo aggrega.ai/ sin subdominio tiene la disciplina más estricta: está reservado solo para anotaciones emitidas por la plataforma. El compilador emite aggrega.ai/compiler-version, aggrega.ai/component-id, aggrega.ai/recipe-uri, aggrega.ai/boundary-path y claves de procedencia relacionadas en la salida renderizada; el contenido del usuario que declara directamente una anotación aggrega.ai/<key> se rechaza en el momento de la publicación. La disciplina impide que las anotaciones escritas por el usuario colisionen con la procedencia emitida por la plataforma.
Los prefijos de subdominio bajo <sub-domain>.aggrega.ai/ son el espacio de las convenciones del catálogo. La biblioteca estándar usa component.aggrega.ai/type (la etiqueta de la ontología cloud-native), feature.aggrega.ai/kind (la partición de las Feature entre operativas y de credenciales), compliance.aggrega.ai/* (las etiquetas del eje de cumplimiento) y subespacios de nombres acotados similares. Cada subdominio lo gobierna un público concreto del catálogo: component.aggrega.ai/* los autores de entidades Component, feature.aggrega.ai/* los autores de entidades Feature y compliance.aggrega.ai/* el público de las políticas de cumplimiento. Las lecturas entre subdominios (un plugin Wasm que lee de varios subespacios de nombres) están permitidas pero son raras; cada plugin suele limitarse a un solo subespacio de nombres.
Los prefijos de dominio empresarial (acme.com/..., my-org.io/...) son la superficie de extensión de la plataforma. El compilador de Aggrega los trata como metadatos opacos; los consumen los plugins Wasm empresariales. Las empresas escriben la estructura de prefijos que se ajuste a su gobernanza — plana (acme.com/owner: team-payments), de subdominio (security.acme.com/scope: pii) o jerárquica (org.acme.com/billing-center: finance). La plataforma no restringe la disposición de los prefijos empresariales; la única regla es que los prefijos empresariales no colisionen con aggrega.ai/ ni con sus subdominios.
La disciplina importa porque las anotaciones se propagan en cascada — las anotaciones escritas en el subsistema de un Aggregate se propagan a cada componente del subsistema, las anotaciones propias de una instancia de componente prevalecen sobre las de su subsistema, y las anotaciones de un módulo llegan a los componentes propios del módulo; las anotaciones en una frontera de una Release se propagan a cada componente de la frontera. Una anotación de proveedor llega a la salida renderizada desde cualquiera de los dos lados, y donde ambos escriben la misma clave se aplica el valor de la Release. Sin disciplina de prefijos, una anotación del lado del Aggregate podría sobrescribir en silencio una clave de procedencia emitida por la plataforma, o una anotación empresarial podría colisionar con una clave de convención del catálogo. La tabla de prefijos hace explícitos los públicos y hace aplicable en el momento de la publicación la regla de prevención de colisiones.
Consulta language-reference/vocabulary/labels-and-annotations.md para ver la enumeración de las superficies de anotación por entidad y la semántica de cascada de tres compartimentos (.context.annotations.release / .context.annotations.catalog / .context.annotations.aggregate).