aggrega build
aggrega build compila um par Aggregate + Release em artefactos nativos do fornecedor (manifestos Helm, charts Helm redistribuíveis, YAML de docker-compose) em dist/ na raiz do espaço de trabalho, conforme descrito em Saída. A Release é o ponto de entrada único: nomeia o Aggregate e o Manifest, declara fronteiras e encaminha componentes para fornecedores.
Flags comuns
Duas flags têm um comportamento que a referência de flags abaixo não consegue transmitir por si só:
--catalog <dir>— um diretório que contém entidades de catálogo — os tipos de autoria Component, Feature, Recipe e FeatureRecipe, juntamente com os tipos de biblioteca, Aggregates e Plugins —, carregado de forma recursiva. Cada diretório--catalogé pesquisado antes dos configurados, pela ordem indicada. Para pesquisar um catálogo local do projeto a par de um partilhado, passe ambos (--catalog ./catalog --catalog ../shared-catalog) ou liste-os emcatalog_dirs. Com--detail, qualquer entidade que um diretório de maior precedência oculte é reportada no stderr, juntamente com os outros avisos da compilação. Um diretório--catalogque não existe interrompe a compilação, nomeando-o. O mesmo faz um diretório listado emcatalog_dirsque não é um diretório, antes de qualquer coisa ser lida ou escrita, nomeando a entrada e o ficheiro de configuração e a linha que a listam — ver De onde são lidas as entidades locais. Uma compilação que é interrompida porque uma referência não foi resolvida para nada nomeia, na nota por baixo da interrupção, cada ficheiro nesses diretórios que declara uma apiVersion do Aggrega — uma linha que começa, sem indentação, comapiVersion:e um valor iniciado poraggrega.ai/— e que não pôde ser carregado, por exemplo um que não é analisado como YAML, com o motivo dado pelo próprio analisador, entre os ficheiros de catálogo ignorados no carregamento; um ficheiro YAML que declara outra apiVersion, ou nenhuma, não é um documento do Aggrega e nunca é aí nomeado.--detail— reporta o que o passo de pull fez, o mesmo diagnóstico transitório de eventos de pull queaggrega pull --detailemite. O que decide se há algo a reportar é se um passo de pull foi pedido — com--auto-pullou ativandoauto_pull— e não se já existe um lockfile: um passo de pull pedido é executado em qualquer dos casos, preenchendo um lockfile em falta e respeitando as fixações de um existente. Quando nenhum passo de pull é executado, a flag imprime uma nota de uma linha no stdout e prossegue — nunca fabrica um nível de resolução que o lockfile confirmado não contenha. Para o estado de resolução pós-pull das dependências de uma Release, useaggrega inspect.
--dry-run é abordada em Pré-visualizar uma compilação sem a escrever, e --trace e --trace-unredacted em Saída de rastreio e Mostrar os valores ocultados abaixo.
Preencher o lockfile como parte da compilação
Por predefinição, a compilação é só de leitura quanto às dependências: precisa de um lockfile e não escreve nenhum. --auto-pull e a definição de espaço de trabalho auto_pull acrescentam o passo de pull à compilação, para que um único comando resolva as dependências da Release e compile com base no que resolveu.
Uma edição da Release é algo que o lockfile deteta. O lockfile regista a Release — e cada Release que ela estende — pelo digest do seu conteúdo, pelo que uma compilação só de leitura sobre uma Release editada desde o pull para antes de qualquer renderização, nomeando o ficheiro e indicando que se execute aggrega pull --release <release>, que regista a edição respeitando todas as outras fixações. Uma alteração de comentário ou de espaços em branco conta, porque o digest abrange os bytes tal como estão. Uma compilação com pull automático executa ela própria esse passo de pull, pelo que regista a edição e compila.
A Release é renderizada uma vez. As entradas externas que uma Release consome decorrem da sua renderização e não de algo que os seus documentos declarem, pelo que o passo de pull renderiza a Release para o descobrir — e essa renderização é a da compilação. Uma compilação com pull automático custa, portanto, uma renderização, o mesmo que uma compilação simples sobre um lockfile já existente.
As flags que moldam uma renderização aplicam-se a ela. --trace, --verify-determinism, --disable-plugin-cache e --no-unsupported-field-warnings chegam à renderização que uma compilação com pull automático executa nos mesmos termos em que chegam à de uma compilação simples, pelo que pedir um rastreio ou uma verificação de determinismo numa compilação de um só comando produz um. --dry-run é a exceção, e é uma recusa e não um silêncio: uma execução de teste não escreve nada enquanto o passo de pull escreve, pelo que a combinação para antes de qualquer trabalho (consulte Pré-visualizar uma compilação sem a escrever).
Como uma compilação lê o que o lockfile fixa
Uma fixação do lockfile nomeia conteúdo — um digest — e não um local. Para uma entidade, é o digest do que uma publicação dela transporta, o seu documento e os ficheiros que nomeia, pelo que uma cópia de uma entidade num diretório de catálogo e uma entrada de cache que contém a sua publicação têm a mesma fixação, como descreve O lockfile. Uma compilação lê cada dependência fixada a partir das fontes já presentes na máquina: primeiro os diretórios de catálogo, como em todo o lado, e depois a cache de conteúdo em .aggrega/cache. Lê-las não consulta nenhum registo; só o passo de pull, quando uma compilação o executa, faz obtenções.
Uma entrada de cache que já não contém a sua fixação é ignorada. Uma entidade editada no local — um novo corpo sob a mesma version — deixa a cache de conteúdo com o corpo anterior sob esse nome e versão. Quando um diretório de catálogo contém uma cópia cujo conteúdo tem como digest a fixação, a compilação lê essa cópia e nunca lê a entrada, e indica-o no erro padrão, nomeando a entrada e ambos os digests:
reuse: cache entry for <name>:<version> holds <digest the entry holds>, not the pinned <pinned digest>; passed over for <catalog file>, which holds the pinned bytesQuando nenhum diretório de catálogo contém a entidade, uma entrada de cache completa com exatamente os bytes fixados é lida como a dependência, pelo que uma entidade removida do seu diretório de catálogo depois de a sua cópia publicada ter sido obtida continua a compilar a partir dessa cópia.
Quando nenhuma fonte contém os bytes fixados, a compilação para antes de qualquer renderização, com E0135 — ou E0133 quando o manifesto da entrada de cache não é o que o lockfile fixa. A paragem nomeia a fixação, a entrada de cache e o digest que contém, e cada cópia da entidade num diretório de catálogo com o seu digest, ou indica que nenhum diretório de catálogo a contém. A solução é um pull com um registo acessível, que obtém novamente a versão fixada e confronta o que obtém com a fixação; consulte Respeitar vs. atualizar para saber o que o pull faz quando o registo já não serve esses bytes.
A renderização que aggrega pull executa para descobrir entradas externas, e uma compilação ou pré-visualização através de aggrega serve ou aggrega mcp, leem as suas fixações da mesma forma.
Entradas externas no momento da compilação
Uma renderização pode pedir conteúdo de um URL remoto — o esquema de valores de um chart com uma referência remota, por exemplo — e uma compilação nunca obtém um para o acrescentar ao que a renderização pode ler. Um pedido de um URL que o lockfile já fixa é servido a partir do armazenamento de entradas do espaço de trabalho e verificado contra o digest registado antes de qualquer byte chegar à renderização. Um pedido de um URL não fixado para a compilação, nomeando o URL e o passo que o fixa; não há nenhuma definição que transforme essa paragem numa obtenção, porque alargar discretamente o conjunto de entradas que uma compilação lê é precisamente o que uma compilação reprodutível não pode fazer.
Quando a cópia de uma entrada fixada desapareceu do armazenamento, essa entrada é obtida novamente pelo digest que o lockfile já regista e verificada contra ele antes de algo ser escrito ou devolvido. Isso não pode alterar o que a renderização vê — o digest foi fixado quando a entrada foi fixada — pelo que repara o armazenamento em vez de acrescentar ao fecho, e o lockfile fica inalterado byte a byte. Na postura offline não há transporte nem para isso, e a cópia em falta faz parar a compilação, nomeando a postura.
A fixação acontece quando as dependências da Release são resolvidas, pelo que o que uma compilação pode ler fica decidido antes de a compilação começar. aggrega pull é esse passo, e é o único.
O registo de confiança dos plugins
Vários dos comportamentos de uma compilação dependem de plugins-trust.yaml, o ficheiro confirmado ao lado do lockfile da Release que regista para que plugin resolveu cada anexação que devolve veredictos — uma anexação plugins.governance numa função ir-verdict ou render-verdict, e todas as anexações plugins.linter. aggrega pull escreve-o e o esquema do registo de confiança dos plugins descreve os seus campos; o que se segue é apenas o que a própria compilação faz com ele.
Uma compilação é confrontada com o registo antes de qualquer um desses plugins ser executado. Um plugin servido a partir da cache cujo digest de artefacto não é o registado é recusado em vez de executado — essa é a resolução que uma anexação destas normalmente segue, e aggrega pull descreve que outras formas de a resolver o digest registado não rege. E uma entrada registada que nenhuma anexação em .aggrega-config.yaml justifica faz parar a compilação: retirar um controlo não altera nenhum byte renderizado, pelo que a saída produzida sem um controlo revisto parece exatamente igual à saída que esse controlo aprovou. A paragem nomeia o plugin e oferece as duas soluções que diferem consoante a intenção — anexá-lo novamente se a remoção foi um engano, ou pedir a remoção explicitamente se não foi — e imprime o comando pronto a executar. Uma anexação que o registo ainda não contém é uma primeira ocorrência, e nenhuma das comparações para por causa dela.
Uma compilação confronta cada um desses plugins com a assinatura que a sua entrada regista, exatamente como confronta uma entrada do lockfile com a que essa entrada regista. Quando uma entrada regista uma signature verificada, a compilação volta a calcular o hash do pacote de assinatura que esse facto nomeia na cache antes de qualquer renderização, e para com E0144 quando o pacote está em falta ou é diferente. Para um plugin que lê a partir da cache de conteúdo, lê também desse pacote para que artefacto a assinatura foi feita, e para com E0332 quando foi feita para um plugin diferente do que a compilação leu — que é o aspeto de uma signature copiada de outra entrada —, independentemente do que diga o requisito de assinatura. Para um plugin servido pela cache de conteúdo, qualquer das recusas nomeia aggrega pull --release <release>: o pull seguinte verifica novamente a assinatura do plugin, regista a do próprio plugin e coloca em cache o pacote que ela nomeia, reescrevendo uma cópia em cache que já não corresponda ao seu digest. Quando a configuração de confiança do espaço de trabalho exige uma assinatura para um plugin que a compilação lê a partir da cache de conteúdo — nas mesmas definições que levariam aggrega pull a recusá-lo sem assinatura, pelo que skip_signature_verification e um registo advisory deixam a compilação prosseguir tal como deixam o pull —, uma entrada que não regista nenhuma assinatura, ou a ausência de qualquer entrada para o plugin, para a compilação com E0331, nomeando o plugin, plugins-trust.yaml e as definições que exigem a assinatura. A solução é aggrega pull --release <release>, que verifica a assinatura do plugin no seu registo em cada execução e a regista. Um plugin servido a partir de um dos seus diretórios de catálogo, ou a partir da cópia incluída no binário do compilador, nunca é sujeito a esse requisito. Tal como o resto da compilação, isto lê ficheiros já presentes na máquina e não consulta nenhum registo.
Uma compilação nomeia cada retirada que o registo contém, ao lado de cada uma que o lockfile contém. Um marcador que aggrega pull registou para um desses plugins é reportado como uma linha deprecation: que nomeia o plugin, a severidade registada e a mensagem do editor, em qualquer severidade, e build.halt_on_deprecated_severity decide se também interrompe a compilação, pela mesma regra que aplica a uma referência fixada. Todas as outras superfícies que reportam sobre uma Release nomeiam o mesmo conjunto com as mesmas palavras, e nenhuma delas é interrompida por isso: aggrega validate --release, aggrega lint --release, aggrega inspect --closure, a validação e a resposta de fecho do servidor de linguagem, e as ferramentas describe e validate do assistente. Um registo que existe e não pode ser lido interrompe a compilação em vez de passar por um que não regista nada.
aggrega build --upgrade reescreve esse ficheiro. Implica --auto-pull e executa uma atualização completa simples, que volta a resolver todas as dependências e, por isso, volta a resolver e reescreve todas as identidades registadas, e descarta todas as entradas que nenhuma anexação justifica. Assim, se este ficheiro aparecer modificado depois de uma compilação com upgrade, é esse o motivo: o alcance da flag são todas as dependências, e as identidades registadas fazem parte do que é resolvido novamente, embora não sejam fixações do lockfile. Ao contrário de aggrega pull --upgrade, a flag da compilação não aceita um alvo, pelo que não pode ser restringida a um plugin: para adotar ou descartar uma única identidade, execute antes aggrega pull --upgrade --release <release> <plugin>, que deixa intactas todas as outras fixações e todas as outras identidades registadas.
Como o seu alcance é tudo, pergunta antes de começar. aggrega build --upgrade confirma a atualização nos mesmos termos que o aggrega pull --upgrade simples — os dois são o mesmo ato, por isso fazem a mesma pergunta. Passe --yes para responder antecipadamente em uso não interativo; com a entrada padrão que não é um terminal e sem --yes, a compilação recusa em vez de esperar por uma resposta que ninguém pode dar. Uma compilação que não faz atualização não pergunta nada.
Resolução do espaço de trabalho e determinismo
A referência manifest: exigida pelo esquema da Release é resolvida em relação ao ficheiro da Release. Uma entrada relativa de catalog_dirs (e um caminho relativo de plugin no sistema de ficheiros) é resolvida em relação ao diretório do .aggrega-config.yaml que a declarou — «relativo» significa sempre relativo ao ficheiro em que foi escrito, pelo que um caminho significa o mesmo onde quer que se invoque aggrega. Uma flag --catalog, que não tem ficheiro declarante, é resolvida em relação ao diretório de trabalho atual. As referências de registo (oci://…, uma referência de hub) ficam como estão.
A raiz do espaço de trabalho é o diretório do .aggrega-config.yaml ascendente mais próximo que contém um bloco workspace:, ou o diretório que --workspace-root nomeia. Quando a raiz é fixada desta forma, uma compilação é independente do local de invocação: executar aggrega build a partir da raiz do projeto e a partir de um subdiretório produz IR e artefactos renderizados idênticos byte a byte, porque o catálogo pesquisado e os caminhos de origem registados na saída não mudam com o diretório de trabalho. (Sem marcador workspace: e sem --workspace-root, o diretório de trabalho é a raiz, pelo que a saída fica ancorada nele — a menos que o diretório de trabalho não ancore nada e --release nomeie a Release por um caminho absoluto: a raiz é então novamente descoberta a partir da própria pasta da Release, pelo que o catálogo pesquisado e os caminhos registados na saída são os do projeto a que a Release pertence, seja qual for o local a partir do qual o comando é executado. Consulte configuration.md.) Quando também não é encontrado nenhum espaço de trabalho dessa forma e nada nomeia um, a compilação avisa no erro padrão que a pasta que usou como raiz não está dentro de nenhum espaço de trabalho e nomeia o comando que a torna um; uma compilação a que se pediu que resolvesse primeiro as suas dependências é recusada antes de qualquer obtenção, porque a cache que essa resolução preenche seria escrita nessa pasta e torná-la-ia um espaço de trabalho. Uma compilação que não resolve nada primeiro continua a renderizar, mas, pela mesma razão, uma entrada externa que o lockfile fixa e que a cache já não contém não é obtida novamente: o plugin que a pede recebe, em seu lugar, a frase da recusa, tal como recebe a da postura offline, e a compilação reporta o que esse plugin faz com ela. Um --workspace-root ou AGGREGA_WORKSPACE_ROOT que nomeie uma pasta inexistente é recusado antes de a compilação fazer qualquer outra coisa, nomeando qual dos dois o forneceu.
Variáveis de ambiente
As definições do espaço de trabalho que a compilação lê podem ser substituídas através do ambiente, acima da configuração confirmada e abaixo de qualquer flag: AGGREGA_OFFLINE, AGGREGA_AUTO_PULL, AGGREGA_CATALOG_DIRS (separada como lista de caminhos do sistema operativo; forneça caminhos absolutos), AGGREGA_ARTIFACT_CACHE_DIR, AGGREGA_DEFAULT_REGISTRY e AGGREGA_WORKSPACE_ROOT. Consulte environment-variables.md para a lista completa e o modelo de precedência.
Saída
Os artefactos renderizados ficam em dist/ sob a raiz do espaço de trabalho, seja qual for a pasta a partir da qual o comando é executado — a própria raiz, uma pasta abaixo dela ou uma pasta noutro local com a raiz nomeada por --workspace-root ou AGGREGA_WORKSPACE_ROOT — e a linha final nomeia esse diretório por extenso:
Build completed: 4 files written to <workspace>/dist<workspace> representa aqui a raiz do espaço de trabalho, que a linha escreve como caminho completo. Quando não é encontrado nenhum espaço de trabalho e nada nomeia um, a pasta a partir da qual o comando foi executado é a raiz, pelo que dist/ é escrito aí. Um dist que seja uma ligação que sai do espaço de trabalho é recusado antes de algo nele ser removido ou escrito. Uma Release que não declara fronteiras escreve por fornecedor: dist/<provider>/<files>. Uma fronteira declarada sem directory: escreve por fronteira e por fornecedor: dist/boundaries/<boundary-path>/<provider>/<files>. As substituições directory: e subDirectory: escritas pelo operador nas fronteiras da Release alteram o caminho de destino; o colapso por (path, provider) funde os contribuidores que resolvem para o mesmo caminho avaliado.
Ficheiros que a compilação não escreveu
Uma compilação escreve os seus próprios ficheiros e não remove nada que não tenha escrito, com uma exceção: dist/boundaries/, que uma compilação regenera por completo, é esvaziado antes da escrita, para que um ficheiro aí deixado por uma compilação de outra variante não sobreviva numa árvore que já não o produz. Tudo o resto em dist/ fica como está — um ficheiro que uma compilação anterior escreveu e que esta já não produz, um ficheiro que o directory: de um boundary aí colocou numa execução anterior e um ficheiro que o próprio utilizador aí colocou, sem distinção —, porque a compilação não consegue distinguir um resto de um ficheiro que se mantém aí de propósito.
O que faz em vez disso é informar. Depois de escritos os seus ficheiros, a compilação examina o próprio dist/ e cada diretório abaixo dele no qual escreveu um ficheiro ou pelo qual passou para escrever um mais fundo, e nomeia cada ficheiro aí presente que não escreveu nesta execução, num único aviso no erro padrão. Os ficheiros são nomeados pelos seus caminhos relativos a dist/, ordenados, para que a mesma árvore seja reportada da mesma forma em todas as execuções:
warning: the output directory holds 2 file(s) this build did not write, in directories it wrote into; nothing was removed, so they sit beside this build's output: "app/stale-from-earlier-run.yaml", "beside-the-tree.txt"A linha final conta-os depois:
Build completed: 1 file written to <workspace>/dist, beside 2 files this build did not writeUm diretório no qual a compilação não escreveu nada, nem diretamente nem mais abaixo, não é examinado, pelo que uma pasta própria mantida em dist/ não é listada ficheiro a ficheiro. Uma compilação que não encontra nenhum ficheiro desse tipo não imprime nenhum aviso, e a sua linha final é a apresentada em Saída. Em qualquer dos casos, os ficheiros que a compilação escreve são os mesmos bytes. Para comparar duas compilações, ou para começar do zero, remova dist/ antes de compilar.
O pedido aggrega/build de aggrega serve e a ferramenta build do assistente (aggrega mcp) escrevem através do mesmo passo, pelo que nomeiam os mesmos ficheiros na mesma frase: o daemon como um dos notices da sua resposta, e a ferramenta como o último dos seus advisories. Uma execução de simulação não escreve nada, pelo que não reporta nada disto.
Indentação YAML
Todos os artefactos YAML renderizados — ficheiros docker-compose, templates e valores de charts Helm e manifestos Kubernetes — são emitidos com uma largura de indentação uniforme. A largura é definida por build.yaml_indent em .aggrega-config.yaml e é, por predefinição, 2 (a largura convencional para esses formatos):
build: yaml_indent: 2 # default; accepts 2 through 9A largura é aplicada num único ponto de serialização partilhado por todos os renderizadores, pelo que a saída se mantém idêntica byte a byte entre execuções da mesma entrada. Os valores fora do intervalo [2, 9] são rejeitados pela validação do esquema de configuração.
Devolver o grafo compilado
--ir-graph escreve no stdout, em JSON, o grafo que esta compilação resolveu. É aditiva: os artefactos continuam a ser escritos em dist/, o resumo continua a ser impresso e os bytes renderizados não mudam. O grafo sai antes de tudo o resto que a compilação imprime aí — um documento JSON e uma quebra de linha final — pelo que um consumidor que descodifique o fluxo o lê e para.
O grafo devolvido é aquele que a renderização consumiu, pelo que descreve exatamente a compilação que produziu os artefactos ao seu lado e não uma segunda resolução da mesma Release. Combina-se com --dry-run: o grafo é escrito e o relatório de artefactos segue-se-lhe, sem nada escrito em disco.
Os valores que um autor declarou sensíveis são-lhe ocultados — incluindo os values e infra de uma ligação, quando o socket do componente consumidor declara uma folha sensível —, na forma estruturada descrita em aggrega inspect. --unredacted ao lado de --ir-graph imprime-os em vez disso, nos termos que aggrega inspect --unredacted estabelece: chega ao grafo e a nada mais — os ficheiros de rastreio têm o seu próprio --trace-unredacted, e os artefactos renderizados nunca são ocultados — e tudo aquilo a que a saída chegue passa então a transportar esses valores em claro. Passada sem --ir-graph, é recusada, porque não haveria nada para revelar.
A mesma flag, com o mesmo significado, existe em aggrega inspect e aggrega validate.
Pré-visualizar uma compilação sem a escrever
--dry-run executa a mesma compilação que uma compilação normal executa — os mesmos controlos de dependências, a mesma renderização, os mesmos fornecedores — e imprime o que emitiria em vez de o escrever. Cada artefacto é reportado com o caminho que ocuparia e o conteúdo que teria:
aggrega build --release releases/production.yaml --dry-run==> <workspace>/dist/main/helm/webapp-configmap-webapp.yaml <==apiVersion: v1kind: ConfigMap...
Total build time: 2.5sDry run: 1 file would be written to <workspace>/dist; nothing was writtenOs artefactos são reportados pela ordem em que uma compilação os escreve, pelo que a mesma entrada reporta os mesmos bytes na mesma sequência, e o caminho reportado é aquele em que uma compilação escreveria — sob a raiz do espaço de trabalho, escrito por extenso onde acima está <workspace>.
O que não é escrito. O diretório de saída fica exatamente como está — também não é limpo, pelo que a saída de uma compilação anterior sobrevive intacta a uma execução de teste. O lockfile não é escrito. Nada é escrito em .trace/.
As entradas externas comportam-se exatamente como numa compilação normal, nos termos que Entradas externas no momento da compilação estabelece. Uma execução de teste lê, portanto, o mesmo fecho fixado que a compilação que representa leria, e o que mostra é o que essa compilação escreveria.
Quando uma referência foi recusada, a execução nomeia todas as que não conseguiu alcançar e indica o comando que as fixa:
note: the lockfile does not pin every external reference this render requested, so the following were declined and the render stopped short of the artifacts it would otherwise emit: - https://charts.example.com/values-schema.json Run `aggrega pull --release releases/production.yaml` to pin the inputs the render needs, then run the dry run againExecute aggrega pull uma vez e a execução de teste tem tudo o que precisa; nada mais nela muda.
Uma execução de teste precisa de um lockfile e nunca preenche um. Por predefinição, a compilação é só de leitura, e uma execução de teste mantém-se assim independentemente da forma como foi pedido um preenchimento. --auto-pull e --upgrade são recusadas sem mais (abaixo); a definição de espaço de trabalho auto_pull é substituída nessa invocação, pelo que um espaço de trabalho que preenche por predefinição pode continuar a ser pré-visualizado. Sem lockfile, uma execução de teste para com a mesma solução que uma compilação normal só de leitura indica: execute primeiro aggrega pull.
As flags que recusa. Três flags escrevem, pelo que combiná-las com uma execução de teste não tem um resultado honesto — ignorar a escrita faria desaparecer um preenchimento pedido, e respeitá-la quebraria a única promessa que a execução de teste faz. Cada combinação para antes de qualquer trabalho, nomeando a flag passada e o passo a executar em alternativa:
| Combinada com | Motivo da recusa |
|---|---|
--auto-pull | preenche o lockfile; execute aggrega pull como passo próprio |
--upgrade | volta a resolver todas as dependências e reescreve o lockfile; execute aggrega pull --upgrade como passo próprio |
--trace | escreve ficheiros por nó em .trace/; execute a compilação com rastreio sem --dry-run |
Tudo o resto se combina normalmente. --verify-determinism renderiza cada nó duas vezes e compara os bytes sem escrever nenhum deles, e --catalog, --quiet, --progress, --debug e os filtros de avisos comportam-se exatamente como numa compilação que escreve.
Para que serve e para que não serve. Uma execução de teste responde a «o que emitiria esta Release», que é uma pergunta a que só uma renderização pode responder — pelo que não substitui aggrega validate, que verifica a correção sem renderizar, nem aggrega inspect, que consulta o grafo antes da renderização. Recorra a uma execução de teste quando a resposta pretendida são os próprios artefactos: rever o que uma alteração à Release faz à saída, ou verificar uma edição de uma Recipe antes de confirmar algo em dist/.
Saída de rastreio
A flag --trace ativa um despejo de depuração por nó que captura todos os estados intermédios do compilador. A saída fica em .trace/ sob a raiz do espaço de trabalho, ao lado de dist/ (nunca dentro dele; a disposição lado a lado segue a convenção de .git/, .terraform/, node_modules/ e mantém dist/ puramente implementável).
A estrutura de diretórios é por fronteira e por instância:
.trace/└── boundaries/ └── <boundary-path>/ └── <instance-id>/ ├── 01-pillars-initial.yaml ├── 02-provides-evaluation.yaml ├── 03-inject-hydration.yaml ├── 04-inject-mapping.yaml ├── 05-source-resolution.yaml ├── 06-source-locals.yaml ├── 07-values-mapping.yaml ├── 08-workload-synthesis.yaml ├── 09-artifact-evaluation/ │ └── <per-artifact-file>.yaml ├── 09b-feature-rendering-boundary.yaml ├── 10-engine-synthesis/ │ └── <per-synthesized-file>.yaml ├── 11-engine-emission.log └── 12-labels-injected.logCada posição captura um estado específico do compilador:
01-pillars-initial.yaml— o instantâneo por nó do contexto que um template lê, tirado depois da resolução e antes de qualquer mutação por fase. Contém.values,.infra,.context,.parameters,.metadata.02-provides-evaluation.yaml— as saídasprovides:resolvidas depois da avaliação de provides.03-inject-hydration.yaml— o pipe.context.injectfundido depois da hidratação de inject (vista do lado do consumidor dosprovidesa montante).04-inject-mapping.yaml— o pipe.context.injectdepois das reescritas deinjectMappingda FeatureRecipe.05-source-resolution.yaml— o conteúdosource:analisado que o fornecedor vai consumir. Presente apenas quando a Recipe declarasource:.06-source-locals.yaml— o blocolocals:resolvido. A resolução da fonte publica.localsantes de avaliar o templatesource:, e é por isso que esta posição é escrita quer a Recipe declaresource:quer não.07-values-mapping.yaml— a saída renderizada devaluesMapping:(o dicionário que o fornecedor recebe). Presente apenas quando a Recipe declaravaluesMapping:.08-workload-synthesis.yaml— o contexto tal como estava quando o templateworkload:foi avaliado e a sua saída analisada. Presente apenas quando a Recipe declaraworkload:(inline ou carregado por$import:). OWorkloadanalisado não está nesta posição: aparece a partir de09-artifact-evaluation/, quando já está estabelecido e não em curso.09-artifact-evaluation/— um ficheiro por artefacto avaliado. Presente apenas quando a Recipe declaraartifacts:(com entradas inline ou carregadas por$import:por entrada).09b-feature-rendering-boundary.yaml— o contexto tal como fica no fim da renderização do nó, depois de as FeatureRecipes associadas a ele terem gerado os seus recursos, com oworkloadanalisado ao lado. Escrito para todos os nós.10-engine-synthesis/— um ficheiro por manifesto sintetizado que o fornecedor produziu a partir do Workload (modo workload de helm/compose). Presente apenas quando o fornecedor executou um caminho de síntese.11-engine-emission.log— o resumo pós-emissão (número de ficheiros, caminhos de saída) do nó.12-labels-injected.log— as etiquetas e anotações de proveniência escritas na saída renderizada do nó.
A partir de 03-inject-hydration.yaml, uma posição que mostra o contexto do nó contém o bloco .context.inject sempre que o pipe que capta entrega pelo menos uma chave, por qualquer mecanismo: env, file, arg, ou um mecanismo de outro nome no qual escreve um mapeamento inject, o injectMapping de uma FeatureRecipe ou o próprio bloco inject: do componente. Um nó cuja única entrega é um desses mecanismos personalizados também mostra o bloco, com esse mecanismo sob o seu próprio nome e as suas chaves em all, e um valor declarado sensível aparece como <redacted> em ambos os sítios. Uma posição captada enquanto o pipe não entrega nada não tem bloco .context.inject.
O escritor de rastreio não é bloqueante: o rastreio é escrito em disco em paralelo com a compilação e não no caminho desta. A latência da compilação não é afetada pela E/S do rastreio — a mesma compilação termina no mesmo tempo real quer --trace esteja ativada quer não.
Valores declarados sensíveis no rastreio
Um dado que um autor declarou sensível — uma folha de esquema com sensitive: true, ou uma chave de entrega cujo material veio de uma chave provides que o tenha — é escrito no rastreio como o texto fixo <redacted>. A chave é mantida e só o valor é substituído, pelo que uma posição continua a mostrar que folhas e que chaves de entrega um nó contém. Um irmão não declarado no mesmo bloco imprime o seu valor literalmente; a substituição segue a declaração e nada mais.
Um valor que uma FeatureRecipe entrega através do seu próprio injectMapping também é ocultado. É essa a via para a qual uma posição que declara uma lista inject vazia passa a entrega, e a via que uma realização de credenciais apenas por inject segue. A chave de entrega que um mapeamento destes escreve é ela própria um template, pelo que nenhuma declaração a nomeia; o que se lê em vez disso é o texto do próprio mapeamento. Quando esse texto referencia uma folha values ou infra que a Feature anexada declara sensitive: true, todas as chaves de entrega que o mapeamento produziu aparecem como <redacted> — incluindo uma chave que não transporta nada sensível, já que a leitura é por anexação e não por chave. Um mapeamento que não referencia nada declarado imprime as suas chaves literalmente.
Um valor que um template calculou a partir de um dado declarado sensível também é ocultado, mesmo que a sua própria chave não tenha declaração. O que o identifica é a referência que o autor escreveu: uma entrada locals: cujo template lê uma folha declarada sensível é ocultada, tal como um campo source: que o faça. A leitura é conservadora — um template que alcança um objeto inteiro alcança todas as folhas declaradas sob ele, pelo que {{ range $k, $v := .values.creds }} oculta a sua saída quando algo sob creds está declarado — e uma entrada locals: que lê um irmão já ocultado é, por sua vez, ocultada. Uma entrada irmã com a mesma forma que não lê nada declarado é impressa literalmente.
Um valor que atravessa uma aresta uses é ocultado segundo as declarações do alvo, não as do nó consumidor, e é ocultado em ambas as superfícies para onde a aresta o leva. .context.uses.<alias>.provides reproduz o que o componente alvo publicou, pelo que o que rege esses valores é o esquema do alvo: uma chave provides que o alvo declarou sensível aparece como <redacted> na posição do consumidor mesmo quando o consumidor não declara nada. Quando o próprio bloco inject da aresta encaminha essa chave para uma chave de entrega do componente consumidor, .context.inject oculta também essa chave de entrega — a mesma regra que o mapeamento inject de uma anexação já segue, lendo a mesma declaração. A ocultação é por aresta, pelo que duas arestas que publicam o mesmo nome de chave provides são resolvidas de forma independente: aquela cujo alvo a declarou é ocultada e a outra é impressa literalmente. O resto da aresta — o seu alvo, o seu socket, as suas etiquetas e os próprios nomes de chave do mapeamento inject — não é regido pela declaração provides de um alvo e é impresso literalmente.
Os values e infra por ligação escritos na própria aresta são regidos, em vez disso, pelo socket do componente consumidor: o valueSchema e o infraSchema que esse socket declara, que são os contratos com base nos quais essa configuração é validada. Uma folha que qualquer um dos dois contratos declare sensitive: true aparece como <redacted> em .context.uses.<alias>.values ou .context.uses.<alias>.infra, mantendo-se a chave, e o mesmo acontece com uma folha que esteja num valor predefinido declarado pelo contrato; um elemento irmão não declarado é impresso literalmente. As declarações do alvo não têm aqui qualquer papel, e a ocultação é por ligação, pelo que uma folha com o mesmo nome numa ligação cujo socket a declara legível é impressa literalmente.
As anexações escritas numa ligação são mostradas sob a aresta dessa ligação, em .context.uses.<alias>.features.<slot>, e cada uma é ocultada segundo as declarações da sua própria Feature — as mesmas que regem essa Feature quando um componente a detém diretamente. Uma folha values ou infra que a Feature declara sensitive: true aparece como <redacted>, tal como uma chave dos provides resolvidos da anexação que a Feature declara sensível; cada chave é mantida. O tipo, a versão e as etiquetas da anexação, e todas as folhas e chaves provides que a sua Feature deixa sem declaração, são impressos literalmente, pelo que um localizador publicado continua legível ao lado do material que localiza. A ocultação é por ligação e por posição, pelo que a mesma Feature escrita em duas ligações é resolvida em cada uma. Uma posição que declara sensitive: true — no componente ou no seu socket — indica que a anexação lida com material secreto e não oculta nenhuma folha por si só: que folhas são ocultadas cabe à Feature declarar. As anexações próprias de um componente não estão entre os blocos que uma posição mostra, já que o rastreio não contém nenhum bloco .features; o que um template workload: lê de uma delas é coberto pela nova renderização abaixo.
O Workload analisado é uma nova renderização, não uma captura do documento que a compilação emitiu, e as posições que o contêm — 09-artifact-evaluation/, 10-engine-synthesis/ e 09b-feature-rendering-boundary.yaml — indicam-no numa entrada workload_note ao seu lado. Um documento renderizado não regista nada sobre a declaração de onde veio um dado carácter, pelo que não há nenhuma chave na qual substituir dentro dele. O que o rastreio mostra em vez disso é o mesmo template workload: avaliado uma segunda vez, contra um contexto cujos dados declarados sensíveis já aparecem como <redacted>. Como o template vê uma cadeia onde havia uma cadeia, o resultado mantém a forma do documento emitido: os mesmos campos, nos mesmos lugares, com <redacted> na própria posição do dado ocultado e o texto literal à sua volta inalterado.
Duas formas em que essa nova renderização difere do que foi emitido, ambas indicadas na nota:
- Um template que se ramifica em função do conteúdo de um valor renderiza de forma diferente. Um
eqcontra um valor específico, um teste de comprimento, um hash ou uma codificação dele: cada um vê<redacted>e produz um resultado diferente — um ramo diferente, um comprimento diferente, um digest diferente. É por isso que o rastreio nunca afirma mostrar o documento emitido. - Os dados que nenhuma declaração nomeia passam inalterados. A substituição abrange o que o eixo nomeia — uma folha
values/infradeclarada, uma chave de entrega marcada, uma chaveprovidesque o próprio Component do componente declara sensível, osprovidesdeclarados de um alvo consumido, uma folha dosvaluesouinfrapróprios de uma ligação que o seu socket declara sensível, uma folha declarada ou uma chaveprovidesde uma anexação que o próprio componente detém (lida em.features.<name>) ou de uma escrita numa ligação, e um valorlocals:ousource:calculado a partir de um deles. São os mesmos dados pelos quais é ocultada uma recusa gerada pelo template. Um dado que chegue ao template por qualquer outra via, como uma chaveprovidesque nenhuma declaração nomeia e cujo valor uma Recipe calculou a partir de uma folha declarada, aparece na nova renderização exatamente como aparece no documento emitido.
Quando a nova renderização não pode de todo ser produzida, a posição mantém a chave workload: e substitui o documento por uma linha que o indica e nomeia --trace-unredacted. A declaração é deliberada: uma projeção que simplesmente desaparecesse seria indistinguível de uma Recipe que não declara nenhum workload:.
Há um limite que vale a pena ler antes de tratar .trace/ como seguro: dist/ não é ocultado. Os artefactos renderizados são emitidos exatamente como a renderização os produziu, porque são o que se implementa, e a nova renderização do rastreio nunca os alcança — a mesma entrada renderiza de forma idêntica byte a byte quer --trace esteja ativada quer não.
Trate .trace/ como contendo material sensível e manuseie-o da mesma forma que dist/.
Mostrar os valores ocultados
--trace-unredacted, juntamente com --trace, escreve os valores declarados sensíveis nos ficheiros de rastreio em vez do texto que os substitui. Existe porque o valor ocultado é por vezes precisamente o que se está a depurar — uma credencial vinda da anexação errada parece idêntica à correta quando ambas aparecem como ocultadas.
É também a forma de capturar o documento que a compilação efetivamente emitiu: sem nada ocultado não há nada a substituir, pelo que as posições workload: contêm o documento emitido e não uma nova renderização dele, e a entrada workload_note está ausente.
Três propriedades delimitam-na:
- Cada ficheiro que escreve diz o que é. Cada ficheiro de rastreio que a execução produz começa com um comentário que nomeia a flag e indica que os valores declarados sensíveis aparecem abaixo em claro, pelo que um ficheiro mais tarde anexado a um relatório de erro ou deixado num diretório partilhado contém o seu próprio aviso. O comentário é válido no formato do próprio ficheiro, pelo que o ficheiro continua a poder ser analisado.
- Chega a
.trace/e a nada mais. Os artefactos renderizados são idênticos byte a byte com e sem ela — altera o que um ficheiro de depuração mostra, nunca o que uma compilação produz — e as disposições deaggrega inspecte o texto de diagnóstico que uma compilação falhada imprime são idênticos em ambos os estados. - Existe apenas na invocação. Não há nenhuma definição de configuração para ela, pelo que não pode ser ativada uma vez e deixada ativa para todos os que compilem o espaço de trabalho depois. Pedi-la sem
--tracefaz parar a compilação com uma mensagem que nomeia ambas as flags, em vez de aceitar um pedido que não consegue respeitar.
Independentemente do rastreio, uma compilação imprime um aviso por cada chave de entrega que transporta material declarado sensível como valor literal, nomeando o componente, o alvo, a anexação e a chave de entrega. Nunca faz parar a compilação e --no-unsupported-field-warnings não o silencia — essa flag abrange aquilo que, do que o utilizador escreveu, um alvo não consegue respeitar, uma classe diferente.
A palavra-chave, os seus dois locais de autoria, a redação exata do aviso e o limite completo do que declará-la consegue estão em vocabulary/compact-form-authoring.md, «Declarar uma folha como sensível».
Quando usar --trace
- Diagnosticar porque é que um manifesto renderizado não contém um valor esperado: percorrer os despejos por passagem para encontrar a primeira posição em que o valor está em falta.
- Verificar o determinismo após uma atualização do compilador: duas compilações da mesma entrada com
--traceproduzem despejos de rastreio idênticos byte a byte; qualquer diferença por posição localiza a regressão. - Iteração na autoria de catálogos: comparar os instantâneos
04-inject-mapping.yamle06-source-locals.yamlmostra o que os templates da Recipe veem no momento da avaliação.
Exemplos
Compilar uma Release com o catálogo local:
aggrega build --release releases/production.yamlCompilar com um diretório de catálogo separado:
aggrega build --release releases/production.yaml --catalog ../platform-catalog/Ver o que uma Release emitiria sem escrever nada:
aggrega build --release releases/production.yaml --dry-runCompilar com despejos de rastreio para depuração:
aggrega build --release releases/production.yaml --traceApós a compilação, inspecione .trace/boundaries/<boundary>/<instance>/ para ver o estado por passagem. O diretório .trace/ é substituído em cada execução com --trace; o estado de rastreio anterior não é preservado entre compilações.
Referências cruzadas
aggrega-pull— obter entidades de catálogo de um registo OCI para o catálogo local.aggrega-validate— verificar a correção do catálogo, do fecho da Release ou de uma única entidade sem emitir artefactos; a validação de dependências que uma compilação executa, sem a renderização.aggrega-lint— verificar as convenções de publicação do catálogo nos mesmos três âmbitos.aggrega-inspect— consultar o grafo IR após a finalização do grafo sem avançar para a renderização.- Erros — o formato categorizado de apresentação de erros que surge na CLI.
Sinopse
aggrega build [flags]Descrição
Compile an Aggregate and Release pair into provider-native artifacts under eachboundary's output directory.
The Release is the single entry point: it names the Aggregate and the Manifest,declares the boundaries, and routes each component to a provider. What aprovider emits is the provider's own shape — Helm manifests, a redistributableHelm chart, docker-compose YAML — so the output directory holds whatever theproviders this Release routes to produce.
The output directory is dist/ beneath the workspace root, whichever folder thecommand is run from, and the closing line names it in full. A run that finds noworkspace uses the folder it was run from as the root, and writes dist/ there.
Build is read-only by default and needs a lockfile. Run "aggrega pull" first tocreate one, or pass --auto-pull to fill it in-process for this build.
Given identical input, build writes byte-identical output, which is what makesthe rendered tree reviewable as a diff.Flags
| Flag | Predefinição | Descrição |
|---|---|---|
--auto-pull | false | Executar o passo de pull antes de compilar: resolver as dependências da Release para o lockfile e a cache dentro do processo e depois compilar com base nelas. É o mesmo preenchimento dentro do processo que a definição auto_pull do espaço de trabalho efetua, ativado para uma única compilação sem editar a configuração do espaço de trabalho. Por si só é um preenchimento incremental — as fixações existentes são respeitadas e as referências sem fixação são resolvidas e acrescentadas |
--catalog | [] | Diretório de catálogo; repetível. Cada —catalog <dir> é colocado no início da pilha de pesquisa de catálogos (a primeira correspondência prevalece): os catalog_dirs do espaço de trabalho ou, para uma Release à qual a configuração do espaço de trabalho atribui diretórios próprios em workspace.releases, os dessa Release; a pilha termina com o diretório chamado catalog na raiz do espaço de trabalho, quando existe. Uma lista catalog_dirs escrita vazia não lê nenhum catálogo local. |
--debug | false | Emitir diagnósticos detalhados legíveis por humanos no stderr — tempo real por fase e contagens de entidades/dependências. Prevalece sobre —quiet: a saída detalhada é sempre emitida. Distinto de —trace, que escreve ficheiros intermédios por nó legíveis por máquina em .trace/ |
--detail | false | Por predefinição, a compilação é só de leitura e não imprime detalhes de resolução. Quando o passo de pull é executado — porque —auto-pull foi passada ou o espaço de trabalho ativa auto_pull — a compilação preenche o lockfile dentro do processo, quer já exista um quer não, e esta flag imprime, por entidade resolvida, o que esse preenchimento fez: obtida de novo de um registo, reutilizada uma posição da cache, encontrada num catálogo local, servida a partir do binário do compilador, ou externa (o próprio Aggregate ou Manifest da Release, lido do ficheiro ou da entrada que a Release nomeia). Quando nenhum passo de pull é executado, imprime uma linha a indicá-lo em vez das linhas por entidade. Apenas stdout; não é persistido |
--disable-plugin-cache | false | Ignorar a cache persistente em disco de compilação de plugins nesta compilação e compilar os guests dos plugins de raiz numa cache em memória que é descartada quando a compilação termina. Desativada por predefinição, o que reutiliza a cache partilhada em disco entre compilações. Não altera a saída renderizada |
--dry-run | false | Renderizar a Release e imprimir o que emitiria em vez de o escrever: o caminho que cada artefacto teria e o seu conteúdo vão para o stdout, e o diretório de saída e o lockfile ficam intactos. As entradas externas comportam-se exatamente como numa compilação normal — as entradas fixadas são servidas a partir do armazenamento endereçado por conteúdo (e repostas pelo digest quando o blob está em falta), e uma renderização que pede um URL externo não fixado para, nomeando-o — pelo que o que uma execução de teste mostra é o que uma compilação escreveria. Recusa-se a combinar com —auto-pull, —upgrade ou —trace, cada uma das quais escreve — execute o preenchimento de dependências, ou uma compilação com rastreio, como passo próprio. Combina-se com —policy-input, cujos ficheiros passam então a ser a única coisa que escreve |
--ir-graph | false | Escrever também no stdout, em JSON, o grafo IR que esta execução calculou, além de tudo o que este comando já produz. Os valores que um autor declarou sensíveis são-lhe ocultados; passe —unredacted para os imprimir em vez disso. Os artefactos continuam a ser escritos e o resumo continua a ser impresso; o grafo é escrito antes de ambos |
--no-unsupported-field-warnings | false | Silenciar a classe de avisos de campos não suportados: os avisos que um alvo gera para algo que o utilizador escreveu e que não consegue respeitar — um campo do Workload que não consegue exprimir (como faz um alvo de menor fidelidade como o compose), ou uma anotação aggrega.ai/ sobre a qual não atua para o tipo de entrada do nó. Os outros avisos de renderização continuam a surgir. Apenas de apresentação; não altera a saída renderizada |
--policy-input | — | Escrever, neste diretório, a carga que cada papel de governação entrega a um plugin aí associado, como uma linha de JSON: exatamente o que a compilação entrega ao plugin, com todos os valores que a compilação lhe retém também retidos aqui. Para annotation-transform, label-transform e ir-verdict, o ficheiro é o documento input que uma política nesse papel lê. Para render-verdict, o motor de políticas remodela a carga antes de uma política a ler — os documents de cada artefacto são analisados a partir dela —, pelo que uma política render-verdict num motor integrado se testa numa compilação, associada de modo a reportar em warn ou info; para um plugin cujo .wasm foi compilado pelo próprio utilizador, aggrega plugin run-local --plugin <plugin.wasm> --export verdict_render --with @<dir>/render-verdict.json executa-o sobre esse ficheiro. Também é escrito um papel sem nada associado, como a carga que uma associação sem fontes e sem definições receberia, para que uma política possa ser escrita antes de ser associada. Cada papel é escrito em <role>.json (annotation-transform, label-transform, ir-verdict, render-verdict); quando as associações de um mesmo papel recebem cargas diferentes — uma transporta fontes ou definições próprias, ou uma transformação altera o que a seguinte lê —, cada uma é escrita antes em <role>.<position>.<plugin>.json, em que position conta as associações desse papel a partir de 1 pela ordem em que a configuração do workspace as lista e plugin é o último segmento da referência do plugin sem a versão, com escape de todos os caracteres que um nome de ficheiro não pode conter. Os ficheiros com esses nomes já presentes no diretório são substituídos e nada mais aí é tocado. Os ficheiros são escritos quer a compilação termine quer pare, e uma compilação que pare antes de um papel correr nomeia cada papel para o qual não escreveu nenhum ficheiro. Pedi-los não altera nenhum artefacto nem nenhum veredicto. Combina-se com —dry-run, que então escreve estes ficheiros e mais nada: o diretório de saída e o lockfile ficam intactos |
--progress | false | Forçar a ativação da apresentação do progresso da compilação mesmo quando o stderr não é um terminal, imprimindo uma linha simples por passo à medida que termina, com o seu tempo. A predefinição é auto: a lista de verificação interativa das fases só é mostrada quando o stderr é um terminal que interpreta sequências de escape, um terminal que não as interpreta recebe as mesmas linhas simples, e a saída redirecionada ou encaminhada por pipe não recebe nenhuma. —quiet e —debug sobrepõem-se ambas a —progress |
--quiet | false | Silenciar a apresentação do progresso da compilação no stderr. Não afeta o stdout. Tem precedência sobre —progress |
--release | — | Caminho para o ficheiro YAML da Release (obrigatório). Um caminho relativo é resolvido em relação ao diretório em que o comando é executado, não em relação à raiz do espaço de trabalho. Quando esse diretório não está em nenhum espaço de trabalho e nenhuma raiz é nomeada, um caminho absoluto encontra o espaço de trabalho a partir da própria pasta da Release |
--trace | false | escrever ficheiros intermédios por nó em .trace/ sob a raiz do espaço de trabalho, ao lado de dist/, para inspeção posterior |
--trace-unredacted | false | Escrever os valores declarados sensíveis nos ficheiros de .trace/ em vez do texto |
--unredacted | false | Imprimir os valores que um autor declarou sensíveis em vez de os ocultar. Tudo aquilo a que a saída chegue — um terminal, um pipe, um ficheiro, uma gravação de ecrã — passa então a transportar esses valores em claro. Chega ao grafo que —ir-graph escreve e a nada mais, pelo que requer —ir-graph; os ficheiros de .trace/ usam —trace-unredacted em vez disso |
--upgrade | false | Fazer do passo de pull automático uma atualização completa: descartar o lockfile existente e voltar a resolver todas as dependências a partir do estado atual do registo, fazendo cada uma avançar para a versão mais alta disponível em vez de respeitar as fixações existentes. Implica —auto-pull — por si só executa um pull de atualização completa antes da compilação. Não aceita um alvo, pelo que não pode ser restringida a uma dependência: para adotar ou descartar uma única fixação, execute antes aggrega pull —upgrade —release |
--verify-determinism | false | Renderizar cada nó duas vezes e comparar os bytes emitidos, parando a compilação se as duas renderizações de algum nó diferirem. Desativada por predefinição. Use-a para confirmar que um fornecedor renderiza de forma determinística — uma entrada idêntica produz uma saída idêntica byte a byte — algo de que dependem as garantias de diff GitOps e de saída idêntica byte a byte |
--yes | false | Responder antecipadamente à confirmação de —upgrade, para uso não interativo. Chega a essa única pergunta e a nada mais: uma compilação que não faz atualização não pergunta nada, pelo que passá-la não altera nenhum comportamento nesse caso |