Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Brasil)
Esta página foi traduzida automaticamente. Leia o original em inglês.

Filosofia do ecossistema

A filosofia do ecossistema

A arquitetura do Aggrega é guiada por princípios de design fundamentais que equilibram flexibilidade e previsibilidade. Ao manter fronteiras claras e contratos padronizados, um compilador fundamentalmente genérico consegue orquestrar de forma transparente tudo, desde infraestrutura cloud-native padrão até inteligência de IA altamente especializada.

1. Mecânica central: a física da arquitetura

  • Separação de responsabilidades (lei de Conway): desenvolvedores não escrevem código de infraestrutura física, e Ops não fixa no código a lógica da aplicação. A orientação da arquitetura divide a autoria em fronteiras Domain-Driven, uma separação que o compilador não impõe (veja o Invariante 7).
  • Vinculação tardia (inversão de dependência): desenvolvedores solicitam interfaces abstratas (por exemplo, type: enterprise-agent), não implementações específicas (por exemplo, helm-chart-v2). O Manifest resolve a interface para a implementação correta em tempo de compilação, permitindo verdadeiras implantações multialvo a partir de um único arquivo-fonte.
  • Pureza AOT (sem busca na nuvem ao vivo): O compilador é agnóstico em relação à nuvem ao vivo. Ele nunca se autentica em APIs de infraestrutura nem busca endereços IP ao vivo durante a compilação. Ele opera inteiramente por inversão de controle, mapeando ponteiros determinísticos e passando antecipadamente contratos de injeção abstratos para que o ambiente de execução possa resolver com segurança as conexões físicas finais.

2. A experiência do desenvolvedor: intenção e abstração

  • Experiência semântica do desenvolvedor (o padrão do mapa de 5 palavras-chave): para evitar atrito cognitivo, os desenvolvedores usam exatamente cinco palavras-chave universalmente compreendidas dentro de uma topologia YAML baseada em mapas:
    1. parameters: o contrato de ambiente global (por exemplo, a passagem de tamanhos de disco dinâmicos).
    2. values: o payload central da lógica cognitiva/de negócio (de propriedade dos desenvolvedores).
    3. uses: as arestas de rede e as dependências declaradas explicitamente (de propriedade dos desenvolvedores).
    4. infra: a pegada física e o dimensionamento mecânico (de propriedade de Ops, proibidos no Aggregate).
    5. inject: o contrato de entrega estrito que mapeia variáveis locais para as chaves de destino de provides (env, file, arg). Esse mecanismo é extensível.
  • Terminologia independente de capacidades: para evitar que as realidades da infraestrutura subjacente (como o termo do Kubernetes namespace) vazem para a experiência do desenvolvedor, a plataforma utiliza conceitos universais como boundaries.
  • Intenção explícita e o “guardrail barulhento” (sem infraestrutura fantasma): o compilador nunca deve inventar recursos de computação ou funcionalidades que o desenvolvedor não declarou explicitamente. Usar um mecanismo de políticas para injetar silenciosamente um proxy de segurança cria “infraestrutura fantasma”: quando ela quebra, o desenvolvedor acaba depurando um proxy que não existe no seu YAML. Em vez de alterar silenciosamente a arquitetura, os plugins de política Wasm atuam estritamente como guardrails barulhentos. Se uma topologia viola a segurança, o compilador interrompe o build e retorna um erro bem específico (por exemplo, “Erro: dados PII fluindo para um provedor de modelos através do gateway de IA router. Você deve anexar explicitamente a funcionalidade core/data-masking a ele”), forçando o desenvolvedor a corrigir a sua própria fonte única da verdade.

3. O compilador sem opiniões próprias: processamento e orquestração

  • Políticas programáveis (o compilador sem opiniões próprias): O compilador Go central é um mecanismo de cálculo neutro quanto ao conteúdo. Ele analisa YAML, percorre grafos e avalia interseções de labels. A verdadeira “inteligência” (por exemplo, garantir que o tráfego de modelos que transporta dados restritos passe por um gateway de IA que mascara texto sensível) é programada dinamicamente pela empresa usando sockets WebAssembly (Wasm) plugáveis para mutações da árvore de sintaxe abstrata (AST)—alterando a representação em memória da configuração analisada—e para validação de políticas.
  • Agnosticismo de schemas (dicionário de código aberto): O compilador central é agnóstico em relação às camadas físicas de execução. Ele não possui schemas fixos no código para Helm, Terraform ou Docker Compose. Em vez disso, o bloco source de uma Recipe de Ops é um dicionário aberto cujas chaves são definidas pelo provider e chegam aos templates da Recipe como .source.*. O núcleo resolve uma source buscada por meio de um formato integrado { kind, url, version } (kinds: helm-oci-chart, helm-https-chart, compose-https-fragment, git-repository), o que já desacopla o compilador das linguagens de nuvem que ele manipula. Consulte a referência de source da Recipe para o modelo de busca.
  • Orquestração explícita de Plugin: o compilador Go central atua estritamente como um construtor de grafos neutro e nunca adivinha como processar um nó. Em vez disso, toda a inteligência de domínio é orquestrada explicitamente por meio de sockets WebAssembly (Wasm) dedicados em dois níveis distintos. 1. Sockets globais: as políticas e a formatação da empresa são avaliadas por sockets do compilador registrados explicitamente (por exemplo, o papel de governança label-transform para a marcação automática de metadados, um papel de governança de veredito para a segurança topológica e o socket do renderizador para a geração final dos artefatos). 2. Pipelines de implementação: a lógica de mutação específica do Component é orquestrada pelo Manifest; quando ele resolve uma interface abstrata para uma Recipe concreta, essa implementação declara explicitamente um array sequencial pipeline de plugins Wasm a executar. O compilador simplesmente alimenta esses sockets definidos com o grafo de representação intermediária (IR), independente de capacidades, garantindo que toda a lógica específica de domínio permaneça estritamente versionada no ecossistema em vez de fixada no código do núcleo do compilador.
  • Compilação plana e atomicidade das Feature: o Aggrega não gerencia estado, não faz ping em endpoints nem espera um rollout terminar. O compilador avalia os módulos aninhados e os resolve em um grafo de representação intermediária (IR) plano e unidimensional antes de passar os dados para os plugins de renderização Wasm. Crucialmente, embora o grafo seja achatado, o compilador preserva a atomicidade das Feature. Se uma funcionalidade de proxy declara de forma autônoma uma aresta de rede para um cofre seguro, o compilador registra a origem semântica dessa aresta, garantindo que os mecanismos de políticas Wasm possam executar buscas $O(1)$ sem atribuir erroneamente a conexão ao componente pai. Por fim, para suportar o sequenciamento temporal, cada fronteira na Release carrega um valor syncWave: <integer>; cada plugin de renderização traduz a onda de cada fronteira para o meio com que o seu próprio alvo expressa ordenação — uma anotação de ordem de execução lida pelo controlador GitOps a jusante, ou uma dependência entre os serviços do arquivo que ele gera —, enquanto um alvo sem nenhuma superfície de ordenação registra a onda sem sequenciar com base nela.

4. A ontologia semântica: identificação e taxonomia

  • A ontologia operacional cloud-native: para garantir que plugins Wasm de código aberto e políticas corporativas possam interoperar universalmente, o rótulo component.aggrega.ai/type é mapeado exclusivamente para um conjunto fechado de primitivas de nuvem universais (server, worker, task, function, stateful-server, resource). Esta é a chave própria do Aggrega: o esquema publicado do Component enumera os valores que ela aceita, e um documento que traga qualquer outro valor é recusado ao ser carregado. Fixar esse vocabulário de forma central é o que garante que mecanismos de políticas autônomos e plugins de renderização Wasm criados pela comunidade leiam a mesma palavra para a mesma forma quando encontram um Component que nenhum de seus autores escreveu. Ainda assim, o compilador não infere nada da string: ele compara o valor com um seletor e não provisiona nada por conta própria; o que o conjunto fechado garante é que o seletor de todos compare o mesmo vocabulário.
  • Classificar em um eixo que o Aggrega não define: o conjunto fechado cobre esta única chave reservada. Um catálogo que precisa de sua própria classificação (um nível, uma zona de dados, uma classe de serviço, uma divisão mais fina das primitivas) define sua própria chave de rótulo ao lado da reservada, já que o esquema do Component aceita qualquer chave de rótulo adicional com valor de string e toda superfície de seleção a lê da mesma forma. A extensão acontece na sua chave, não dentro da do Aggrega, e é isso que permite que um vocabulário corporativo cresça sem que o compartilhado se desvie.
  • Duck typing (traços semânticos via rótulos): se os tipos base são puramente cloud-native, toda a inteligência cognitiva, operacional e de conformidade é sobreposta inteiramente por duck typing semântico. Os rótulos definidos pelo Platform Architect (por exemplo, model.aggrega.ai/capability: generative, compliance.aggrega.ai/data-class: restricted) atuam como a verdadeira identidade do nó. As Features se vinculam dinamicamente aos componentes com base nesses seletores de rótulos.

5. Governança corporativa: esquemas e herança

  • Particionamento estrito da API e descoberta corporativa: seguindo os padrões do Kubernetes, todas as definições de payload residem uniformemente em um bloco spec:. A identidade do recurso, os rótulos característicos e as instruções explícitas ao compilador residem estritamente no bloco metadata:. Para garantir uma resolução estrita, todo artefato YAML compartilhável exige estritamente uma string SemVer version validada por regex. Além disso, para suportar a descoberta em registros OCI e a governança do ciclo de vida, o bloco metadata suporta uma suíte de metadados corporativos opcional. Essa suíte inclui description, um array estruturado de objetos maintainers (nome, e-mail, url), license, repository, home (URL da documentação) e keywords (para indexação de busca). O fim de vida é gerenciado fora do documento: aggrega deprecate anexa um marcador de descontinuação assinado — uma severidade, um motivo e um substituto opcional — a um artefato já publicado sem alterar os bytes publicados.

  • Extensibilidade de esquemas (o padrão CRD do Kubernetes): para evitar atualizar o esquema do compilador central a cada nova funcionalidade de IA ou de infraestrutura, a plataforma usa JSON Schema 2020-12 para validar as configurações. Os Platform Architects escrevem tipos estritos, lógica de validação e valores padrão diretamente no bloco schema: dos componentes do catálogo, normalmente em forma compacta, uma notação abreviada com formato de YAML que coloca as restrições de cada campo em uma linha (port: { type: integer, min: 1, max: 65535, default: 8080 }) e é compilada para JSON Schema 2020-12 antes da validação. O YAML completo de JSON Schema continua sendo uma opção de autoria equivalente para esquemas que precisam do seu vocabulário completo. Catálogos que crescem o suficiente para se beneficiar da reutilização de esquemas entre um Component e outro levam formas comuns (blocos de probe, limites de recursos, formas de portas nomeadas) para uma entidade SchemaLibrary dedicada e as referenciam por meio da palavra-chave $ref: do JSON Schema.

  • Herança de esquemas (linhas de base do payload): para que uma linha de base seja definida uma única vez, a plataforma divide a herança em dois níveis distintos. Os metadados YAML padrão (incluindo rótulos semânticos), os mapeamentos do Manifest e as configurações da Release utilizam estratégias de merge tradicionais para permitir as sobrescritas de ambiente necessárias. Os esquemas de payload (schema:) não fazem merge dessa forma, e os dois tipos de catálogo seguem caminhos diferentes: o schema: de uma Feature é composto com o da sua base segundo a semântica de composição do JSON Schema 2020-12, percorrido no carregamento do workspace por um mesclador que marca a proveniência por posição no código-fonte, de modo que cada folha do esquema mesclado carrega o seu arquivo de origem; um Component que estende outro não define nenhum conteúdo de payload: ele escreve o marcador literal schema: inherited e recebe o bloco da sua base exatamente como a base o definiu, em qualquer profundidade de uma cadeia. A linha de base de um Component é, portanto, garantida por construção, e não por política: o contrato do filho simplesmente é o da base, então não há nada que o filho possa relaxar. O que tal Component compõe em vez disso é estrutura (seus slots de anexação, sockets de topologia, a allowlist de autoinjeção e as assertions nomeadas), e um filho que precisa de uma regra mais rígida do que a declarada pela sua base a expressa como uma entrada assertions: adicional, que as regras da base mantêm ao lado em vez de serem substituídas. A segurança topológica mais ampla e a governança de rótulos continuam devidamente delegadas ao socket de governança Wasm.

  • Paridade de interface e implementação automática: para evitar que Ops duplique YAMLs de Recipe quando um Architect cria uma variante ligeiramente alterada de um Component base, uma Recipe escrita para uma base atende todo Component que a estende, em qualquer profundidade da cadeia. O Component que estende escreve schema: inherited, portanto não acrescenta a values/infra/provides nenhuma chave raiz que a Recipe da base seria incapaz de consumir. O Manifest ainda mapeia o tipo que estende com uma entrada própria, e a verificação de mapeamento aceita essa entrada quando o implements da Recipe mapeada nomeia o tipo ou qualquer base que ele estende (veja Uma Recipe escrita para uma base atende tudo o que a estende). O rastreador de infraestrutura fantasma (que emite avisos quando nenhum template declarado pela Recipe vinculada lê uma chave escrita, para evitar a “infraestrutura fantasma”) é o guardrail correspondente da fase de renderização.

  • Correspondência de versão de implements: o campo implements das Recipes e das FeatureRecipes suporta três formas para equilibrar rigor e flexibilidade do ecossistema:

    1. Versão exata: implements: "core/api-server:1.0.0" — corresponde apenas a 1.0.0. Para Recipes fortemente acopladas a uma versão específica do esquema.
    2. Compatível com a major (intervalo SemVer): implements: "core/api-server:^1.0.0" — corresponde a >=1.0.0, <2.0.0. Projetada para Recipes que se apoiam nas garantias de compatibilidade SemVer do Component: incrementos minor e patch são presumidos retrocompatíveis segundo o SemVer, e o compilador verifica se a versão do Component satisfaz o intervalo.
    3. Sem versão: implements: "core/api-server" — corresponde a qualquer versão. Para Recipes genuinamente independentes de versão (por exemplo, uma Recipe genérica de worker que usa apenas .context.inject.env e nenhum campo values específico de versão).

    implements nunca seleciona uma Recipe: o Manifest nomeia a Recipe para cada tipo de componente, e o compilador verifica se o implements da Recipe mapeada aceita esse tipo em uma das três formas, interrompendo em caso de divergência. É pela mesma declaração que o compilador sugere Recipes candidatas quando um tipo de componente não tem mapeamento.

    O padrão de três formas permite que as Recipes declarem o contrato de versão que se ajusta ao seu acoplamento real com o esquema do Component. Recipes fortemente vinculadas a uma versão específica do esquema fixam a versão exata; Recipes que se apoiam nas garantias de compatibilidade SemVer do Component usam um intervalo compatível com a major; Recipes cujo comportamento não depende em nada da versão do Component permanecem sem versão. O resultado é que incrementos minor da versão do Component não obrigam Ops a fixar versões de Component nem a manter Recipes paralelas por versão.