Ir al contenido
AggregaAggrega
Seleccionar idioma: Español
Esta página se tradujo automáticamente. Lee el original en inglés.

Filosofía del ecosistema

La filosofía del ecosistema

La arquitectura de Aggrega se rige por principios de diseño fundamentales que equilibran flexibilidad y previsibilidad. Al mantener límites claros y contratos estandarizados, un compilador fundamentalmente genérico puede orquestar sin fisuras todo, desde la infraestructura cloud-native estándar hasta la inteligencia de IA altamente especializada.

1. Mecánica central: la física de la arquitectura

  • Separación de responsabilidades (ley de Conway): los desarrolladores no escriben código de infraestructura física, y Ops no codifica de forma fija la lógica de la aplicación. Las pautas de la arquitectura dividen la autoría en límites Domain-Driven, una separación que el compilador no impone (consulta la Invariante 7).
  • Enlace tardío (inversión de dependencias): los desarrolladores solicitan interfaces abstractas (p. ej., type: enterprise-agent), no implementaciones específicas (p. ej., helm-chart-v2). El Manifest resuelve la interfaz en la implementación correcta en tiempo de compilación, lo que permite verdaderos despliegues multidestino a partir de un único archivo fuente.
  • Pureza AOT (sin obtención en vivo desde la nube): El compilador es agnóstico respecto a la nube en vivo. Nunca se autentica en las API de infraestructura ni obtiene direcciones IP en vivo durante la compilación. Opera por completo mediante inversión de control, asignando punteros deterministas y pasando por adelantado contratos de inyección abstractos para que el entorno de ejecución pueda resolver de forma segura las conexiones físicas finales.

2. La experiencia del desarrollador: intención y abstracción

  • Experiencia semántica del desarrollador (el estándar del mapa de 5 palabras clave): para evitar la fricción cognitiva, los desarrolladores usan exactamente cinco palabras clave universalmente comprendidas dentro de una topología YAML basada en mapas:
    1. parameters: el contrato de entorno global (p. ej., el paso de tamaños de disco dinámicos).
    2. values: la carga útil central de lógica cognitiva/de negocio (propiedad de los desarrolladores).
    3. uses: las aristas de red y las dependencias declaradas explícitamente (propiedad de los desarrolladores).
    4. infra: la huella física y el dimensionamiento mecánico (propiedad de Ops, prohibidos en el Aggregate).
    5. inject: el contrato de entrega estricto que asigna las variables locales a las claves de destino de provides (env, file, arg). Este mecanismo es extensible.
  • Terminología independiente de las capacidades: para evitar que las realidades de la infraestructura subyacente (como el término de Kubernetes namespace) se filtren en la experiencia del desarrollador, la plataforma utiliza conceptos universales como boundaries.
  • Intención explícita y la «barrera ruidosa» (sin infraestructura fantasma): el compilador nunca debe inventar recursos de cómputo ni funcionalidades que el desarrollador no haya declarado explícitamente. Usar un motor de políticas para inyectar silenciosamente un proxy de seguridad crea «infraestructura fantasma»: cuando falla, el desarrollador acaba depurando un proxy que no existe en su YAML. En lugar de modificar silenciosamente la arquitectura, los plugins de políticas Wasm actúan estrictamente como barreras ruidosas. Si una topología viola la seguridad, el compilador detiene la compilación y devuelve un error muy específico (p. ej., «Error: datos PII fluyendo hacia un proveedor de modelos a través del gateway de IA router. Debes adjuntarle explícitamente la funcionalidad core/data-masking»), lo que obliga al desarrollador a corregir su propia fuente única de verdad.

3. El compilador sin opiniones propias: procesamiento y orquestación

  • Políticas programables (el compilador sin opiniones propias): El compilador Go central es un mecanismo de cálculo neutral respecto al contenido. Analiza YAML, recorre grafos y evalúa intersecciones de etiquetas. La verdadera «inteligencia» (p. ej., exigir que el tráfico hacia los modelos que transporta datos restringidos pase por una pasarela de IA que enmascare el texto sensible) la programa dinámicamente la empresa mediante sockets WebAssembly (Wasm) conectables para mutaciones del árbol de sintaxis abstracta (AST)—que alteran la representación en memoria de la configuración analizada—y para la validación de políticas.
  • Agnosticismo de esquemas (diccionario de código abierto): El compilador central es agnóstico respecto a las capas físicas de ejecución. No posee esquemas codificados de forma fija para Helm, Terraform ni Docker Compose. En su lugar, el bloque source de una Recipe de Ops es un diccionario abierto cuyas claves define el provider y que llegan a las plantillas de la Recipe como .source.*. El núcleo resuelve una source obtenida mediante una forma integrada { kind, url, version } (kinds: helm-oci-chart, helm-https-chart, compose-https-fragment, git-repository), lo que ya desacopla el compilador de los lenguajes de nube que manipula. Consulta la referencia de source de la Recipe para el modelo de obtención.
  • Orquestación explícita de Plugin: el compilador Go central actúa estrictamente como un constructor de grafos neutral y nunca adivina cómo procesar un nodo. En cambio, toda la inteligencia de dominio se orquesta explícitamente mediante sockets WebAssembly (Wasm) dedicados en dos niveles distintos. 1. Sockets globales: las políticas y el formato de la empresa se evalúan mediante sockets del compilador registrados explícitamente (p. ej., el rol de gobernanza label-transform para el etiquetado automático de metadatos, un rol de gobernanza de veredicto para la seguridad topológica y el socket del renderizador para la generación final de artefactos). 2. Pipelines de implementación: la lógica de mutación específica del Component la orquesta el Manifest; cuando resuelve una interfaz abstracta en una Recipe concreta, esa implementación declara explícitamente un array secuencial pipeline de plugins Wasm que ejecutar. El compilador simplemente alimenta estos sockets definidos con el grafo de representación intermedia (IR), independiente de las capacidades, lo que garantiza que toda la lógica específica de dominio permanezca estrictamente versionada en el ecosistema en lugar de codificada de forma fija en el núcleo del compilador.
  • Compilación plana y atomicidad de las Feature: Aggrega no gestiona estado, no hace ping a endpoints ni espera a que termine un rollout. El compilador evalúa los módulos anidados y los resuelve en un grafo de representación intermedia (IR) plano y unidimensional antes de pasar los datos a los plugins de renderizado Wasm. Lo fundamental es que, aunque el grafo se aplana, el compilador preserva la atomicidad de las Feature. Si una funcionalidad de proxy declara de forma autónoma una arista de red hacia un almacén seguro, el compilador registra el origen semántico de esa arista, lo que garantiza que los motores de políticas Wasm puedan ejecutar búsquedas $O(1)$ sin atribuir erróneamente la conexión al componente padre. Por último, para admitir la secuenciación temporal, cada límite de la Release lleva un valor syncWave: <integer>; cada plugin de renderizado traduce la ola de cada límite al medio con el que su propio destino expresa el orden — una anotación de orden de ejecución que lee el controlador GitOps aguas abajo, o una dependencia entre los servicios del archivo que genera —, mientras que un destino sin ninguna superficie de ordenación registra la ola sin secuenciar en función de ella.

4. La ontología semántica: identificación y taxonomía

  • La ontología operativa cloud-native: para garantizar que los plugins Wasm de código abierto y las políticas corporativas puedan interoperar universalmente, la etiqueta component.aggrega.ai/type se asigna exclusivamente a un conjunto cerrado de primitivas de nube universales (server, worker, task, function, stateful-server, resource). Esta es la clave propia de Aggrega: el esquema publicado del Component enumera los valores que admite, y un documento que lleve cualquier otro se rechaza al cargarse. Fijar ese vocabulario de forma central es lo que garantiza que los motores de políticas autónomos y los plugins de renderizado Wasm creados por la comunidad lean la misma palabra para la misma forma cuando se encuentran con un Component que ninguno de sus autores escribió. Aun así, el compilador no infiere nada de la cadena: compara el valor con un selector y no aprovisiona nada por su cuenta; lo que aporta el conjunto cerrado es que el selector de cada uno compare el mismo vocabulario.
  • Clasificar según un eje que Aggrega no define: el conjunto cerrado cubre esta única clave reservada. Un catálogo que necesita su propia clasificación (un nivel, una zona de datos, una clase de servicio, una división más fina de las primitivas) define su propia clave de etiqueta junto a la reservada, ya que el esquema del Component acepta cualquier clave de etiqueta adicional con un valor de cadena y todas las superficies de selección la leen del mismo modo. La extensión se produce en tu clave, no dentro de la de Aggrega, y eso es lo que permite que un vocabulario empresarial crezca sin que el compartido se desvíe.
  • Duck typing (rasgos semánticos mediante etiquetas): si los tipos base son puramente cloud-native, toda la inteligencia cognitiva, operativa y de cumplimiento se superpone íntegramente mediante duck typing semántico. Las etiquetas definidas por el Platform Architect (p. ej., model.aggrega.ai/capability: generative, compliance.aggrega.ai/data-class: restricted) actúan como la verdadera identidad del nodo. Las Features se vinculan dinámicamente a los componentes en función de estos selectores de etiquetas.

5. Gobernanza empresarial: esquemas y herencia

  • Particionado estricto de la API y descubribilidad empresarial: siguiendo los estándares de Kubernetes, todas las definiciones de carga útil residen de manera uniforme en un bloque spec:. La identidad del recurso, las etiquetas características y las instrucciones explícitas para el compilador residen estrictamente en el bloque metadata:. Para garantizar una resolución estricta, todo artefacto YAML compartible exige estrictamente una cadena SemVer version validada por expresión regular. Además, para admitir la descubribilidad en registros OCI y la gobernanza del ciclo de vida, el bloque metadata admite una suite de metadatos empresariales opcional. Esta suite incluye description, un array estructurado de objetos maintainers (nombre, email, url), license, repository, home (URL de la documentación) y keywords (para la indexación de búsqueda). El fin de la vida útil se gestiona fuera del documento: aggrega deprecate adjunta un marcador de obsolescencia firmado — una gravedad, un motivo y un reemplazo opcional — a un artefacto ya publicado sin cambiar sus bytes publicados.

  • Extensibilidad de esquemas (el patrón CRD de Kubernetes): para evitar actualizar el esquema del compilador central con cada nueva funcionalidad de IA o de infraestructura, la plataforma usa JSON Schema 2020-12 para validar las configuraciones. Los Platform Architects escriben tipos estrictos, lógica de validación y valores predeterminados directamente en el bloque schema: de los componentes del catálogo, normalmente en forma compacta, una notación abreviada con aspecto de YAML que reúne en una línea las restricciones de cada campo (port: { type: integer, min: 1, max: 65535, default: 8080 }) y se compila a JSON Schema 2020-12 antes de que se ejecute la validación. El YAML de JSON Schema completo sigue siendo una opción de autoría equivalente para los esquemas que necesitan su vocabulario completo. Los catálogos que crecen lo suficiente como para beneficiarse de la reutilización de esquemas entre un Component y otro trasladan las formas comunes (bloques de sondas, límites de recursos, formas de puertos con nombre) a una entidad SchemaLibrary dedicada y las referencian mediante la palabra clave de JSON Schema $ref:.

  • Herencia de esquemas (líneas base de la carga útil): para que una línea base se defina una sola vez, la plataforma divide la herencia en dos niveles distintos. Los metadatos YAML estándar (incluidas las etiquetas semánticas), las asignaciones del Manifest y las configuraciones de la Release utilizan estrategias de fusión tradicionales para permitir las sobrescrituras de entorno necesarias. Los esquemas de carga útil (schema:) no se fusionan de ese modo, y los dos tipos de catálogo toman caminos distintos: el schema: de una Feature se compone con el de su base según la semántica de composición de JSON Schema 2020-12, recorrido al cargar el workspace por un fusionador que etiqueta la procedencia por posición en el código fuente, de modo que cada hoja del esquema fusionado lleva su archivo de origen; un Component que extiende otro no define ningún contenido de carga útil: escribe el marcador literal schema: inherited y recibe el bloque de su base exactamente como la base lo definió, en cualquier profundidad de una cadena. Por tanto, la línea base de un Component está garantizada por construcción y no por política: el contrato del hijo simplemente es el de la base, así que no hay nada que el hijo pueda relajar. Lo que un Component así compone en su lugar es estructura (sus ranuras de acoplamiento, sockets de topología, la lista de permitidos de autoinyección y las assertions con nombre), y un hijo que necesita una regla más estricta que la que declara su base la expresa como una entrada assertions: adicional, que las reglas de la base conservan a su lado en lugar de ser reemplazadas. La seguridad topológica más amplia y la gobernanza de etiquetas siguen debidamente delegadas al socket de gobernanza Wasm.

  • Paridad de interfaz e implementación automática: para evitar que Ops duplique YAML de Recipe cuando un Architect crea una variante ligeramente modificada de un Component base, una Recipe escrita para una base sirve a todo Component que la extiende, a cualquier profundidad de la cadena. El Component que extiende escribe schema: inherited, por lo que no añade a values/infra/provides ninguna clave raíz que la Recipe de la base sea incapaz de consumir. El Manifest sigue mapeando el tipo que extiende con una entrada propia, y la comprobación del mapeo acepta esa entrada cuando el implements de la Recipe mapeada nombra el tipo o cualquier base que este extiende (consulta Una Recipe escrita para una base sirve a todo lo que la extiende). El rastreador de infraestructura fantasma (que emite advertencias cuando ninguna plantilla declarada por la Recipe vinculada lee una clave escrita, para evitar la «infraestructura fantasma») es la barrera correspondiente de la fase de renderizado.

  • Coincidencia de versiones de implements: el campo implements de las Recipes y las FeatureRecipes admite tres formas para equilibrar el rigor con la flexibilidad del ecosistema:

    1. Versión exacta: implements: "core/api-server:1.0.0" — coincide solo con 1.0.0. Para Recipes estrechamente acopladas a una versión de esquema específica.
    2. Compatible con la versión mayor (rango SemVer): implements: "core/api-server:^1.0.0" — coincide con >=1.0.0, <2.0.0. Pensada para Recipes que se apoyan en las garantías de compatibilidad SemVer del Component: se asume que los incrementos menores y de parche son retrocompatibles según SemVer, y el compilador comprueba que la versión del Component satisface el rango.
    3. No versionada: implements: "core/api-server" — coincide con cualquier versión. Para Recipes realmente independientes de la versión (p. ej., una Recipe genérica de worker que solo usa .context.inject.env y ningún campo values específico de una versión).

    implements nunca selecciona una Recipe: el Manifest nombra la Recipe para cada tipo de componente, y el compilador comprueba que el implements de la Recipe mapeada acepta ese tipo en una de las tres formas, y se detiene si no coinciden. Esa misma declaración es la forma en que el compilador sugiere Recipes candidatas cuando un tipo de componente no tiene mapeo.

    El patrón de tres formas permite que las Recipes declaren el contrato de versión que se ajusta a su acoplamiento real con el esquema del Component. Las Recipes estrechamente ligadas a una versión de esquema específica la fijan con exactitud; las Recipes que se apoyan en las garantías de compatibilidad SemVer del Component usan un rango compatible con la versión mayor; las Recipes cuyo comportamiento no depende en absoluto de la versión del Component permanecen sin versión. El resultado es que los incrementos menores de versión del Component no obligan a Ops ni a fijar las versiones de los Component ni a mantener Recipes paralelas por versión.