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

Personas

A superfície de criação de Aggrega é dividida entre quatro funções que colaboram. Cada função tem uma preocupação distinta, um ritmo de mudança distinto e um conjunto distinto de tipos de entidade que normalmente cria. Entender qual função você está assumindo indica qual arquivo abrir e quais pilares preencher.

A divisão é uma orientação, não uma regra que o compilador impõe. O compilador central é matematicamente sem opiniões próprias: ele aceita qualquer forma de criação que passe na validação do esquema. Você é livre para combinar funções — um autor que trabalha sozinho costuma usar os quatro chapéus — ou para cruzar uma fronteira quando a situação exigir. As funções existem para manter baixa a carga cognitiva e claras as responsabilidades, não para construir uma prisão. Para o tratamento arquitetural dessa separação, consulte Team Topologies e os quatro domínios.

As quatro funções

Desenvolvedor

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 provedor

Operador de plataforma

conexões por ambiente

Manifests

Releases

Quem normalmente escreve quais arquivos. A divisão é uma orientação, não uma regra que o compilador impõe: em uma equipe pequena ou em um projeto individual, uma única pessoa escreve todos eles.

Desenvolvedor — intenção da aplicação

O desenvolvedor cria o Aggregate: o que a aplicação é e do que ela precisa, expresso como intenção. O desenvolvedor diz “preciso de um banco de dados deste tamanho e de um serviço que o use”, não “provisione uma instância AWS RDS nesta sub-rede”. A infraestrutura física é deliberadamente deixada para o catálogo e para operações, de modo que o Aggregate permanece agnóstico em relação às capacidades — a mesma intenção é compilada para um notebook, uma nuvem ou um cluster corporativo sem que o arquivo do desenvolvedor mude.

Pelo que o desenvolvedor é responsável: os componentes que o Aggregate declara, os values que ele fornece, as Features cujo comportamento é intenção da aplicação (com seus values), os parameters que ele expõe para a variação por ambiente e as arestas uses que conectam os componentes entre si.

Arquiteto de plataforma — o contrato do catálogo

O arquiteto cria Components e Features: os contratos reutilizáveis e versionados que os desenvolvedores consomem. Um Component declara os valores que um desenvolvedor pode fornecer (como um JSON Schema), as saídas que fornece aos consumidores e os sockets que expõe para conexão. Uma Feature declara uma capacidade anexável. O arquiteto constrói a “estrada pavimentada” — a máquina de vendas em que os desenvolvedores fazem seus pedidos — e garante que o que ela entrega tenha o formato correto.

Pelo que o arquiteto é responsável: o schema: que valida os valores do desenvolvedor, as saídas provides, os sockets usesSchema e os rótulos que carregam a identidade semântica. Arquitetos não escrevem infraestrutura física; eles definem a interface para ela.

Operações de plataforma — receitas de infraestrutura

Operações cria Recipes, FeatureRecipes e Plugins de renderização de providers: as traduções específicas de cada provider que transformam um contrato do 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 ao desenvolvedor que o Component declara. Uma FeatureRecipe faz o mesmo para uma Feature no momento da vinculação.

Pelo que operações é responsável: os templates que renderizam a saída nativa do provider a partir dos values do desenvolvedor e do dimensionamento infra do operador, e os valores provides que uma Recipe repassa aos consumidores. Engenheiros de operações reutilizam seu código de infraestrutura existente empacotando-o como Recipes; eles nunca são obrigados a aprender uma linguagem de políticas específica do catálogo.

Operador de plataforma — conexão da implantação

O operador cria Manifests e Releases: a camada de roteamento e a entrada de compilação por ambiente. Um Manifest informa ao compilador qual Recipe realiza cada Component para um determinado destino, de modo que o mesmo Aggregate pode atingir implementações diferentes em cada ambiente. Uma Release é a única entrada de compilação — ela aponta para o Aggregate e o Manifest, atende aos parâmetros que o desenvolvedor expôs, anexa as Features cujas entradas são operacionais, dimensiona com infra as que o desenvolvedor anexou e conecta arestas próprias dentro dos sockets que o arquiteto declarou.

Pelo que o operador é responsável: o mapa de roteamento do Manifest, o atendimento dos parâmetros pela Release, o dimensionamento infra que cada componente recebe, os anexos das Features cujas entradas são operacionais e o infra por aresta que uma Release escreve em uma conexão. O operador atende aos pontos de variação expostos pelo desenvolvedor; a Release não pode introduzir novos valores de aplicação nem nova computação — esses vêm apenas do Aggregate.

Funções são chapéus, não pessoas

Em uma grande empresa, essas quatro funções são departamentos distintos, com conhecimentos diferentes e frequências de mudança diferentes — o catálogo evolui quando a equipe de plataforma entrega uma nova capacidade, as Recipes evoluem quando a infraestrutura muda, as Releases mudam a cada implantação. Em uma equipe pequena ou em um projeto individual, uma só pessoa usa todos os chapéus. Como Components e Recipes são artefatos compartilháveis e versionados, um autor muitas vezes pode ficar apenas na função de desenvolvedor e consumir um catálogo pronto para todo o resto.

Leia em seguida Entidades por função para o mapa completo de tipo para função, incluindo os tipos de biblioteca e de plugin que apoiam as quatro funções.