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

Visão e posicionamento

Este capítulo estabelece o espaço de problemas fundamental, os antiobjetivos rigorosos da plataforma, sua relação com o ecossistema mais amplo e as filosofias gerais que regem o ecossistema do Aggrega.

A lacuna semântica da infraestrutura e como o Aggrega a supera

O cenário de nuvem corporativa é hoje limitado por uma lacuna semântica persistente: as ferramentas tradicionais de Infrastructure-as-Code (IaC) gerenciam o estado físico, mas nativamente não têm o contexto da camada de aplicação.

Ferramentas fundamentais como o Terraform são gerenciadores de estado. Elas provisionam nós de computação físicos, mas não modelam os fluxos de dados lógicos L7 que ocorrem entre esses nós. Elas não conseguem analisar nativamente uma arquitetura para provisionar os firewalls semânticos necessários para rastrear cadeias de prompts de IA ou impedir ataques “Confused Deputy”. Por outro lado, ferramentas nativas do Kubernetes (como o KubeVela) operam como controladores ativos em tempo de execução; os artefatos de conformidade estáticos, gerados antecipadamente (ahead-of-time), exigidos pelas equipes de segurança corporativas ficam fora do seu escopo.

O Aggrega trata disso atuando como um compilador topológico Ahead-of-Time (AOT), voltado para os seguintes gargalos da engenharia de plataforma moderna e dos workloads de IA:

1. Capacidade abstrata vs. mecânica física

  • O problema: quando os desenvolvedores escrevem IaC tradicional, restrições da infraestrutura física (como fixar no código volumes AWS EBS ou tamanhos de instância EC2) frequentemente vazam para a lógica da aplicação. Esse acoplamento forte reduz a portabilidade e prende sem querer os workloads a fornecedores de nuvem específicos.
  • A solução: o Aggrega delega estruturalmente ao catálogo da plataforma a linha entre capacidade abstrata e mecânica física. Em vez de depender de proibições fixadas no compilador, os Platform Architects escrevem declarações rigorosas em JSON Schema 2020-12 (normalmente em forma compacta — uma notação abreviada com aparência de YAML que coloca as restrições de cada campo em uma linha) para governar exatamente o que os desenvolvedores podem solicitar. Normalmente, os desenvolvedores ficam restritos a requisitos abstratos de sobrevivência (por exemplo, storage_size: 100Gi ou hardware/accelerator: gpu) e são impedidos de injetar classes de armazenamento em nuvem arbitrárias, simplesmente porque o schema do componente as rejeitará. Se uma aplicação realmente precisa de um tipo específico de instância física EC2, o Architect deve expor explicitamente esse controle na interface do componente, tornando o aprisionamento a um fornecedor uma escolha consciente e governada, e não um vazamento acidental.

2. Verdadeira inversão de controle e conexão semântica

  • O problema: encadear manualmente endereços IP, strings de conexão de banco de dados (DSNs) e portas de rede entre microsserviços cria arquiteturas frágeis e presas ao ambiente. Embora as organizações hoje gerenciem essas mudanças com camadas complexas de sobrescritas de variáveis, patches do Kustomize ou scripts de deploy duplicados, manter essa lógica de tradução manual introduz um atrito operacional significativo e carga cognitiva ao promover workloads de um laptop local para uma nuvem de produção.
  • A solução: o Aggrega substitui dependências de infraestrutura fixadas no código pela verdadeira inversão de controle (True Control Inversion), por meio de um Injection Contract explícito. Os desenvolvedores simplesmente declaram uma aresta topológica semântica (por exemplo, “o Agente A usa o Banco de Dados B”) e ditam como seu código espera receber os dados de conexão (por exemplo, como variável de ambiente ou arquivo montado). O compilador pega os ponteiros determinísticos atribuídos pelo time de Ops ao destino — seja um nome DNS interno do Kubernetes, uma string de interpolação do Terraform ou um DSN formatado pelo Wasm — e os canaliza diretamente para os templates de renderização sem resolvê-los. Para workloads modernos, isso abstrai o roteamento físico e as portas, tirando-os das mãos do desenvolvedor. O compilador repassa strings determinísticas; uma conexão estável de dependências entre ambientes é uma propriedade da disciplina de autoria da Recipe (o time de Ops fornece ponteiros determinísticos adequados a cada ambiente), não uma garantia do núcleo do compilador.

3. Ligando o jardim murado da IA à realidade cloud-native

  • O problema: os frameworks de IA presumem que a infraestrutura simplesmente existe, deixando para o time de Ops a tarefa de conectar manualmente agentes, pipelines de RAG e bancos de dados usando arquivos YAML fragmentados e fixados no código.
  • A solução: o Aggrega atua como um tradutor topológico. Ao compilar a DSL declarativa do desenvolvedor, o compilador gera as configurações precisas necessárias para conectar loops complexos de raciocínio multiagente diretamente à infraestrutura de nuvem padrão, sem que os desenvolvedores escrevam scripts de infraestrutura.

4. Guardrails impostos pela infraestrutura e defesa contra MCP

  • O problema: guardrails no nível de software falham se uma aplicação for comprometida ou se uma IA alucinar enquanto tem acesso a ferramentas internas pelo Model Context Protocol (MCP).
  • A solução: o Aggrega tira as fronteiras de confiança do código da aplicação e as leva para a infraestrutura de rede por meio de uma rigorosa passagem de execução (Execution Handoff). Depois de validar o grafo estático da aplicação pelo socket de governança WebAssembly plugável, o compilador executa plugins de renderização para gerar as configurações exatas exigidas pelos proxies de interceptação L7 (como mascaramento de dados ou webhooks de aprovação humana). Em seguida, ele entrega esses artefatos ao orquestrador de runtime, que aplica fisicamente as regras e bloqueia ações não autorizadas.

5. Centralizando o tráfego de IA e a governança de gateways

  • O problema: gerenciar o tráfego de LLMs exige um roteamento altamente especializado (orçamentos de tokens, cache semântico, failover) que os gateways padrão de microsserviços não têm.
  • A solução: como o Aggrega é agnóstico em relação às capacidades, a fronteira entre aplicação e infraestrutura depende inteiramente do usuário. O Aggrega pode ser usado em Aggregates “greenfield” de pura infraestrutura, ou pode gerar sob demanda configurações para AI Gateways corporativos se o desenvolvedor as solicitar explicitamente como parte de sua aplicação. Quando solicitadas, o compilador utiliza plugins de renderização WebAssembly e Ops Recipes para gerar os artefatos precisos desses gateways, permitindo que a infraestrutura de runtime execute fisicamente o cache semântico e as cadeias de fallback entre provedores.

6. Memória cognitiva com estado e hospedagem de modelos locais

  • O problema: tratar bancos de dados vetoriais e logs episódicos como armazenamento genérico e plano permite que agentes sequestrados sobrescrevam facilmente fatos semânticos críticos.
  • A solução: o Aggrega trata armazenamentos vetoriais e modelos locais como nós arquiteturais explícitos no grafo de topologia. Com base estritamente no que o usuário solicita e no que o time de Ops implementou em suas Recipes, o compilador utiliza plugins WebAssembly para gerar os artefatos precisos necessários para protegê-los. Isso inclui gerar as políticas de rede rigorosas necessárias para mapear agentes autônomos para partições de memória isoladas e formatar restrições de agendamento específicas (como os nodeSelectors do Kubernetes) para que o orquestrador de runtime coloque os modelos locais em hardware de GPU otimizado.

7. Verdadeiro agnosticismo de nuvem e de capacidades (late binding)

  • O problema: levar uma arquitetura complexa de um ambiente de testes Docker local para o Kubernetes em produção exige manter scripts de implantação completamente separados e duplicados.
  • A solução: o Aggrega se baseia em “late binding”. Os desenvolvedores escrevem uma única planta abstrata. O Platform Operator pode então mapear exatamente a mesma topologia para o Docker Compose em testes locais, ou para AWS/EKS em produção, simplesmente trocando o lockfile Manifest e o roteador Release. Isso desacopla de forma limpa a lógica cognitiva da aplicação da infraestrutura física, oferecendo uma experiência de “escrever uma vez, executar em qualquer lugar” para a arquitetura central e tornando o aprisionamento a um fornecedor uma escolha governada e intencional, e não um subproduto acidental.
graph TD
    A["Single Abstract Blueprint<br/>Aggregate.yaml"]

    subgraph LateBinding ["Late Binding Phase"]
        B{"Manifest Mapping"}
    end

    A --> B

    B -->|"Manifest: local-dev"| C["Local Provider<br/>Docker Compose"]
    B -->|"Manifest: aws-prod"| D["Cloud Provider<br/>EKS + AWS Bedrock"]
    B -->|"Manifest: azure-prod"| E["Cloud Provider<br/>AKS + Azure OpenAI"]

Limites da plataforma e antiobjetivos (o que o Aggrega não é)

Para manter a pureza arquitetural e evitar o crescimento descontrolado do escopo, o Aggrega opera dentro de limites rigorosos e inegociáveis. A plataforma escolhe deliberadamente os problemas que resolve e protege com o mesmo cuidado aquilo que não faz.

1. Um compilador determinístico, não um gerador de IaC

O Aggrega não é um agente de IA que “escreve Terraform para você”. É um compilador Go determinístico que analisa uma linguagem específica de domínio (DSL) rigorosa para garantir artefatos de implantação reprodutíveis e auditáveis. Ele não alucina infraestrutura.

2. Nenhuma lógica cognitiva nem código de aplicação

A divisão de domínios do Aggrega segue a Lei de Conway como orientação, sem impô-la, e o Aggrega não pede às equipes que adotem uma linguagem proprietária. Ele nunca força os desenvolvedores a reescrever sua lógica de raciocínio de IA, nós do LangGraph ou embeddings em Python em uma linguagem de nuvem específica da plataforma. O compilador trata a aplicação como uma caixa-preta. Ele configura as estradas e os muros seguros; os frameworks de aplicação dirigem os carros.

3. Antiobjetivos operacionais e de ciclo de vida

  • Não é um pipeline de CI/CD: o Aggrega não gera imagens Docker, não executa testes unitários nem gerencia repositórios Git. Os desenvolvedores devem usar as ferramentas existentes para compilar o código de suas aplicações. O Aggrega compila estritamente a planta de infraestrutura declarativa que acompanha esses builds.
  • Não é um orquestrador ativo de clusters (sem GitOps): o Aggrega é um compilador estático Ahead-of-Time (AOT), não um agente de cluster ativo que reconcilia o estado continuamente. Ele gera manifestos Kubernetes padrão e configurações do Docker Compose para que ferramentas de GitOps dedicadas (como ArgoCD ou Flux) façam a implantação.
  • Não é um gerenciador de estado cognitivo: o compilador utiliza plugins para gerar as configurações de fronteiras de rede seguras e de bancos de dados físicos. No entanto, ele não monitora o loop de memória interno de um agente de IA. Se uma IA alucinar ou não conseguir gravar em seu banco de dados, o problema é do framework da aplicação.
  • Não é um provisionador de “Day 0”: o Aggrega normalmente pressupõe que já existe um control plane básico (por exemplo, um cluster Kubernetes ativo ou uma conta AWS). Ele compila a arquitetura de aplicação de “Day 1” sobre essa base; não executa os scripts iniciais para criar uma organização corporativa na nuvem.
  • Exceção (Aggregates de plataforma e casos de uso mistos): como o Aggrega é agnóstico em relação a capacidades, ele oferece suporte nativo a cenários “greenfield”. Se um Platform Architect define infraestrutura de Day-0 (como VPCs e clusters Kubernetes) dentro de um Aggregate de plataforma, o Aggrega a compila e renderiza exatamente da mesma forma que faz com uma aplicação padrão. Esse agnosticismo dá suporte sem atrito a ambientes mistos: um nó arquitetural pesado — como um AI Gateway corporativo — pode ser modelado como um recurso de infraestrutura preexistente (usando plugins de formatação que apenas deixam o tráfego passar), ou pode ser implantado diretamente ao lado da aplicação como um componente provisionado padrão.

4. Antiobjetivos de paradigma de aplicação e de infraestrutura

  • Sem redes descentralizadas ou P2P: as configurações geradas dependem de um control plane corporativo centralizado (Kubernetes/VPC) capaz de impor fronteiras de rede L4/L7. O compilador não consegue gerar roteamento seguro para agentes que se descobrem dinamicamente em blockchains descentralizadas ou redes P2P públicas.
  • Sem sistemas zero-copy ou de memória compartilhada: O modelo de segurança do Aggrega depende da geração de configurações para interceptação em nível de rede (como sidecars do Envoy) para aplicar políticas. Se um enxame de agentes se comunica exclusivamente por meio da memória de sistema compartilhada dentro do nó (por exemplo, Ray Core Actors), os proxies de rede não conseguem ver essa comunicação e não conseguem aplicar guardrails.
  • Sem agentes do lado do cliente: o Aggrega é estritamente um compilador de infraestrutura de backend. Ele não consegue gerar configurações para modelos de IA não gerenciados executados inteiramente no navegador Chrome de um usuário final ou em um dispositivo móvel de borda.
  • Sem sandboxing efêmero JIT (microssegmentação por requisição): o Aggrega é um compilador estático AOT projetado para compilar artefatos para computação de longa duração (como Deployments do Kubernetes). Ele não oferece suporte nativo a sandboxing efêmero Just-In-Time (JIT), em que um contêiner inteiro é criado e destruído a cada requisição para limitar o raio de impacto.

5. Relação com ferramentas adjacentes

O socket de renderização WebAssembly (Wasm) plugável do Aggrega permite que a comunidade escreva um plugin de renderização para qualquer ferramenta de destino. O projeto principal inclui plugins de renderização para Helm, Helm-chart, Compose, Terraform e CloudFormation — cobrindo GitOps no Kubernetes, distribuição de charts redistribuíveis, desenvolvimento local e recursos de nuvem declarativos —, enquanto o socket aberto permite que as equipes mirem outras superfícies de artefatos estáticos sem mexer no núcleo. Equipes que avaliam o Aggrega costumam vir de ecossistemas construídos em torno de ferramentas que ficam em partes próximas, mas distintas, da stack. As ferramentas abaixo estão agrupadas pela relação que têm com o Aggrega: os formatos de artefato para os quais ele renderiza, o espaço de compiladores AOT que ele compartilha, os control planes que consomem sua saída e o domínio adjacente de gerenciamento de configuração, que ele não tem como alvo.

Formatos de artefato para os quais o Aggrega renderiza. São as saídas para Kubernetes e desenvolvimento local que os plugins de renderização incluídos produzem; os renderizadores de Terraform e CloudFormation incluídos aparecem ao lado dessas ferramentas no próximo grupo.

  • Helm é o formato padrão de empacotamento e templates para software Kubernetes. O Aggrega emite tanto YAML do Helm renderizado quanto umbrella charts como destinos de saída de primeira classe, de modo que fluxos baseados em Helm consomem diretamente a saída do Aggrega.
  • Docker Compose é o padrão para desenvolvimento local com vários contêineres. O renderizador de Compose do Aggrega o tem como alvo direto, de modo que uma única planta roda localmente sem uma superfície de autoria separada.

O espaço dos compiladores AOT. Essas ferramentas também compilam uma intenção abstrata ou em nível de código em artefatos estáticos e param antes de implantá-los. O Aggrega mira vários dos mesmos artefatos finais por meio de seu socket de renderização aberto; onde nenhum plugin de renderização é incluído para um destino, ele é alcançável escrevendo um, em vez de alterar o núcleo.

  • Terraform / OpenTofu provisionam recursos de nuvem a partir de HCL declarativo e gerenciam o estado por meio de um mecanismo de CLI. O Aggrega compila para artefatos estáticos e deixa a execução do estado para o runtime; seu renderizador de Terraform incluído emite uma configuração que o Terraform ou o OpenTofu aplica, e nunca executa nenhum dos dois.
  • AWS CloudFormation, Azure Resource Manager (ARM) / Bicep e Google Cloud Deployment Manager são os formatos nativos de provisionamento declarativo de suas respectivas nuvens. O Aggrega inclui um renderizador de CloudFormation que emite templates de stack; ARM / Bicep e Deployment Manager são destinos de artefatos estáticos para os quais um autor pode renderizar pelo socket aberto.
  • AWS CDK e CDKTF são compiladores AOT estáticos que traduzem código de propósito geral em JSON do CloudFormation e JSON do Terraform, respectivamente. O Aggrega mira os mesmos tipos de artefatos estáticos finais por meio de seu socket de renderização, então os dois chegam a um mesmo artefato por caminhos diferentes: CDK e CDKTF a partir de código de propósito geral, o Aggrega a partir de uma planta topológica declarativa.
  • Pulumi permite que os desenvolvedores escrevam infraestrutura em linguagens de propósito geral (TypeScript, Python, Go); seu valor central é tratar a infraestrutura como código executável. A superfície de autoria do Aggrega é uma planta YAML declarativa — os desenvolvedores escrevem contra a abstração, não contra a superfície da API. Cada um reflete uma filosofia diferente sobre onde fica o contrato do desenvolvedor com a infraestrutura.
  • AWS SAM e o Serverless Framework traduzem estaticamente uma especificação YAML em recursos de funções serverless e de API gateway — um subconjunto específico do espaço de artefatos que o socket do Aggrega pode ter como alvo.
  • Nitric, Klotho e Winglang são modelos de programação cientes da nuvem cujos compiladores AOT emitem arquivos de infraestrutura padrão a partir do código da aplicação, e não de uma planta de topologia declarativa.
  • Score.dev é uma abstração declarativa para a capacidade básica de workloads — CPU, memória, portas — renderizada em Docker Compose ou Helm. Ele trata de um subconjunto específico do que o Aggrega cobre: topologia entre componentes, um socket de governança para políticas, adaptadores Wasm e capacidades específicas de IA estão fora do escopo do Score.

Control planes que consomem a saída do Aggrega. Eles operam dentro de um cluster em execução e aplicam artefatos declarativos. O Aggrega é estritamente ahead-of-time — ele produz os manifestos que esses sistemas reconciliam.

  • ArgoCD e Flux são controladores de GitOps que reconciliam em um cluster os manifestos armazenados no Git. Eles aplicam a saída Kubernetes do Aggrega como qualquer outro YAML declarativo.
  • Crossplane e KubeVela são operadores ativos do control plane do Kubernetes que reconciliam o estado desejado de dentro de um cluster. Um cluster com Crossplane ou KubeVela pode consumir a saída Kubernetes do Aggrega como qualquer outro YAML declarativo; as duas camadas se complementam.
  • Microsoft Radius é um control plane da aplicação à infraestrutura que reconcilia o estado desejado de dentro de um cluster, consumindo artefatos declarativos do tipo que o Aggrega produz.
  • Spinnaker é um mecanismo de entrega contínua que implanta artefatos em destinos de VM e Kubernetes, depois da etapa de geração de artefatos ocupada pelo Aggrega.

Gerenciamento de configuração adjacente. Essas ferramentas tratam de problemas de estado de servidores e de aplicação de patches em YAML distintos da compilação de topologia, e o Aggrega não tem como alvo o domínio delas.

  • Ansible é uma ferramenta imperativa de gerenciamento de configuração para playbooks sequenciais em VMs de longa duração e frotas on-premise. O Aggrega emite artefatos de topologia declarativos para destinos de contêineres e APIs de nuvem. Equipes que usam o Ansible para gerenciar o estado de servidores ao lado de workloads em contêineres normalmente o mantêm para esse papel e usam o Aggrega para a topologia da aplicação.
  • Chef, Puppet e SaltStack são sistemas de gerenciamento de configuração baseados em agentes que fazem o estado dos servidores convergir nas frotas — um domínio de problemas diferente da compilação estática de topologia.
  • Kustomize aplica patches ao YAML do Kubernetes sem templates e é integrado ao kubectl. Ele transforma manifestos existentes em vez de compilar neles uma planta de topologia.