Personas
A superfície de autoria do Aggrega está dividida por quatro papéis colaborativos. Cada papel tem uma preocupação distinta, uma cadência de mudança distinta e um conjunto distinto de tipos de entidade que normalmente escreve. Perceber que papel se está a desempenhar indica que ficheiro abrir e que pilares preencher.
A divisão é uma orientação, não uma regra que o compilador imponha. O núcleo do compilador é matematicamente sem opiniões próprias: aceita qualquer padrão de autoria que passe a validação de esquema. Há liberdade para fundir papéis — um autor individual assume habitualmente os quatro — ou para atravessar uma fronteira quando a situação o exige. Os papéis existem para manter a carga cognitiva baixa e as preocupações claras, não para construir uma prisão. Para o tratamento arquitetónico desta separação, ver Topologias de equipa e os quatro domínios.
Os quatro papéis
Programador
intenção da aplicação
Aggregate
Arquiteto de plataforma
o contrato do catálogo
Components
Features
Operações de plataforma
receitas de infraestrutura
Recipes
FeatureRecipes
Plugins
de renderização por fornecedor
Operador de plataforma
ligações por ambiente
Manifests
Releases
Quem escreve normalmente que ficheiros. A divisão é uma orientação, não uma regra que o compilador imponha: numa equipa pequena ou num projeto individual, uma só pessoa escreve-os todos.
Programador — intenção da aplicação
O programador escreve o Aggregate: o que a aplicação é e de que precisa, expresso como intenção. O programador diz «preciso de uma base de dados deste tamanho e de um serviço que a use», e não «aprovisiona uma instância AWS RDS nesta sub-rede». A infraestrutura física é deliberadamente deixada ao catálogo e às operações, para que o Aggregate se mantenha agnóstico em relação às capacidades — a mesma intenção compila para um portátil, uma cloud ou um cluster empresarial sem que o ficheiro do programador mude.
O que o programador detém: os componentes que o Aggregate declara, os values que fornece, as Features cujo comportamento é intenção da aplicação (com os seus values), os parameters que expõe para variação por ambiente e as arestas uses que ligam os componentes entre si.
Arquiteto de plataforma — o contrato do catálogo
O arquiteto escreve Components e Features: os contratos reutilizáveis e versionados que os programadores consomem. Um Component declara os valores que um programador pode fornecer (como JSON Schema), os outputs que fornece aos consumidores e os sockets que expõe para ligação. Uma Feature declara uma capacidade associável. O arquiteto constrói a «estrada pavimentada» — a máquina de venda a que os programadores fazem pedidos — e garante que o que ela dispensa está bem formado.
O que o arquiteto detém: o schema: que valida os valores do programador, os outputs provides, os sockets usesSchema e as etiquetas que transportam a identidade semântica. Os arquitetos não escrevem infraestrutura física; definem a interface para ela.
Operações de plataforma — receitas de infraestrutura
As operações escrevem Recipes, FeatureRecipes e Plugins de renderização de provider: as traduções específicas do provider que convertem um contrato de catálogo em infraestrutura renderizada. Uma Recipe mapeia os valores declarados de um Component para um provider concreto — Helm, Docker Compose, Terraform — sem alterar os valores voltados para o programador que o Component declara. Uma FeatureRecipe faz o mesmo para uma Feature no momento da associação.
O que as operações detêm: os templates que renderizam a saída nativa do provider a partir dos values do programador e do dimensionamento infra do operador, e os valores provides que uma Recipe encaminha para os consumidores. Os engenheiros de operações reutilizam o seu código de infraestrutura existente empacotando-o como Recipes; nunca são obrigados a aprender uma linguagem de políticas específica do catálogo.
Operador de plataforma — ligação da implementação
O operador escreve Manifests e Releases: a camada de encaminhamento e a entrada de compilação por ambiente. Um Manifest indica ao compilador que Recipe realiza cada Component para um dado destino, para que o mesmo Aggregate possa atingir implementações diferentes em ambientes diferentes. Uma Release é a única entrada de compilação — aponta para o Aggregate e o Manifest, satisfaz os parâmetros que o programador expôs, associa as Features cujas entradas são operacionais, dimensiona com infra as que o programador associou e liga arestas próprias dentro dos sockets que o arquiteto declarou.
O que o operador detém: o mapa de encaminhamento do Manifest, a satisfação dos parâmetros da Release, o dimensionamento infra que cada componente recebe, as associações das Features cujas entradas são operacionais e o infra por aresta que uma Release escreve numa ligação. O operador satisfaz os pontos de variação expostos pelo programador; a Release não pode introduzir novos valores da aplicação nem nova computação — estes vêm apenas do Aggregate.
Os papéis são chapéus, não pessoas
Numa grande empresa, estes quatro papéis são departamentos distintos, com competências diferentes e frequências de mudança diferentes — o catálogo evolui quando a equipa de plataforma disponibiliza uma nova capacidade, as Recipes evoluem quando a infraestrutura muda, as Releases mudam a cada implementação. Numa equipa pequena ou num projeto individual, uma só pessoa assume todos os papéis. Como os Components e as Recipes são artefactos partilháveis e versionados, um autor pode muitas vezes manter-se puramente no papel de programador e consumir um catálogo pré-construído para tudo o resto.
Leia a seguir Entidades por papel para o mapa completo de tipos por papel, incluindo os tipos de biblioteca e de plugin que apoiam os quatro papéis.