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

Provider Helm

O fornecedor helm produz YAML do Kubernetes renderizado plano para consumidores de GitOps (ArgoCD, Flux). O fornecedor monta por (path, provider): o YAML renderizado de cada nó destinado ao helm é encaminhado para o montador indexado pelo directory: avaliado da fronteira unido ao subDirectory: de cada componente, e esse montador emite um ficheiro YAML por recurso do Kubernetes. As ferramentas a jusante comparam e aplicam os ficheiros diretamente, sem uma etapa de instalação do Helm.

Onde o syncWave: <integer> da fronteira não é 0, cada recurso do Kubernetes emitido tem-no como a anotação argocd.argoproj.io/sync-wave: "<N>"; os hooks do Helm têm também helm.sh/hook-weight: "<N>". O ArgoCD lê a anotação sync-wave, e o Helm lê o peso de um hook, e cada um ordena os recursos por esse valor; uma fronteira na wave predefinida 0 não tem nenhum dos dois, o que ambas as ferramentas leem como wave 0.

Esta página é a referência de autoria do fornecedor helm. Para o modelo de composição de entradas comum aos fornecedores, consulte architecture/16-recipe-input-composition.md. Para a prontidão de cada fornecedor, consulte Estado da linguagem → Providers.

Tipos de entrada suportados

O fornecedor helm aceita os três tipos de entrada da Recipe, em papéis diferentes:

  • Modo com fonte. Uma Recipe com source: <chart-path> aponta para um diretório de chart Helm em disco. O SDK Go do Helm carrega o chart, o dicionário de valores da renderização base é combinado com os valores predefinidos do chart, e os templates do chart são renderizados em YAML plano do Kubernetes.
  • Modo Workload (sintetizado). Uma Recipe com workload: (em linha ou carregado através de $import:) declara um documento Workload. O fornecedor sintetiza um ou mais recursos do Kubernetes por nó — um objeto controlador escolhido pelo form do Workload, mais Services por serviço e PVCs por volume persistente — diretamente a partir da especificação do Workload; consulte Modo Workload (sintetizado).
  • Modo apenas artefactos. Uma Recipe com artifacts: e sem source: nem workload: emite os manifestos que o seu autor escreveu, com as etiquetas e anotações de proveniência da compilação inseridas nos próprios metadados de cada recurso.

Os três combinam-se: uma Recipe pode declarar em conjunto um chart, um Workload e artifacts:, e cada um é renderizado e emitido por si, lado a lado na saída do nó — consulte O que cada provider aceita, na íntegra.

Conjunto de chaves de source:

O source: do fornecedor helm indica um chart, e aceita as duas formas que o campo source: assume: uma cadeia simples de caminho do sistema de ficheiros e um objeto estruturado cujo url: contém a localização. Sempre que essa localização é um caminho do sistema de ficheiros, é ancorada ao diretório que contém o recipe.yaml que a declara, e não ao diretório a partir do qual a compilação é invocada, e tem de permanecer dentro desse diretório: um caminho que saia dele, ou um absoluto, é recusado, porque cada ficheiro que uma publicação da Recipe contém é retirado do seu diretório — consulte entities/recipe.md «Content paths stay inside the Recipe’s own directory (Os caminhos de conteúdo permanecem dentro do próprio diretório da Recipe)». Um chart indicado desta forma é publicado com a Recipe, com cada ficheiro sob ele que as regras de exclusão registadas quando a Recipe foi fixada mantêm — o fornecedor helm deixa de fora os diretórios de controlo de versões e os ficheiros ocultos sob o templates/ do chart, respeita o próprio .helmignore do chart, e o .aggregaignore do autor tem a palavra final, como descreve Que ficheiros acompanham uma entidade — enquanto um ficheiro ao lado da Recipe que nada do que ela declara indica não o é. A renderização lê os mesmos ficheiros que a publicação contém, pelo que um chart é renderizado da mesma forma a partir do diretório do autor e a partir de um registo. A forma em que foi escrito não altera isso: um source: estruturado cujo url: é ./charts/api-server é ancorado exatamente como a cadeia simples ./charts/api-server.

spec:
capability: helm
source: ./charts/api-server # filesystem path to a chart directory
valuesMapping: |
image: "{{ .values.image }}"
replicas: {{ optional .infra `replicas` 2 }}

Um source: estruturado diz a mesma coisa com campos com nome, e o que o seu url: contém decide se algo é obtido. Quando url: contém um esquema de transporte — oci://… para um chart OCI, um https://….tgz para um arquivo de chart direto, ou uma raiz de repositório https:// combinada com chart: — o chart é obtido: o tipo vem do esquema do URL ou de um kind: explícito, aggrega pull obtém e fixa o chart no lockfile, e a compilação extrai-o da cache. Quando url: indica um caminho do sistema de ficheiros, nada é obtido e nada é fixado — o chart é lido do disco, ancorado exatamente como a forma de cadeia simples acima.

spec:
capability: helm
source:
kind: helm-oci-chart
url: ./charts/api-server # a path, so nothing is fetched and nothing is pinned
version: "1.0.0"

Só url: decide de onde um chart é lido. Os outros campos selecionam o que seria obtido, pelo que para um caminho não selecionam nada — continuam, ainda assim, a chegar aos próprios templates da Recipe como .source.*.

Copiar um chart localmente (vendoring) é suportado como alternativa a obtê-lo, e não é obrigatório. O esquema aceita um objeto estruturado aberto.

O chart no caminho de origem tem de conter um Chart.yaml válido. As renderizações com fonte que não conseguem carregar o chart expõem literalmente o erro subjacente do SDK do Helm. Um source: "" vazio não é uma questão do helm: não indica nem o modo sem fonte nem o modo com fonte, pelo que a recusa que recebe é a mesma qualquer que seja o fornecedor a que a Recipe se destina, e surge quando a Recipe é lida, antes de qualquer chart ser carregado e antes do despacho para este fornecedor. Os comandos que a comunicam estão descritos em entities/recipe.md «Source field scheme inventory (Inventário de esquemas do campo source)» e errors/fatal-halts.md «Recipe source: is an empty string (O campo source da Recipe é uma cadeia vazia)».

Modo com fonte

Uma Recipe com source: <chart-path> e valuesMapping: executa o seguinte pipeline na renderização base:

  1. O chart em <chart-path> é carregado através do SDK Go do Helm.
  2. O template valuesMapping é avaliado em relação ao contexto de template da Recipe. A sua saída YAML é tratada como uma sobreposição de valores para o chart.
  3. A sobreposição é combinada uma única vez com os valores predefinidos do values.yaml do chart; em caso de colisão, prevalecem as chaves da sobreposição (a semântica habitual de helm install --values do Helm). Uma chave que a sobreposição define como null remove o valor predefinido do chart para essa chave — no nível superior, dentro de uma tabela ou nos valores de uma dependência — tal como faz helm install --values, pelo que os templates do chart leem a chave como ausente; um null numa chave à qual o chart não dá nenhum valor predefinido chega aos templates como null.
  4. O SDK do Helm renderiza os templates do chart em relação aos valores combinados.
  5. O Aggrega injeta os seus metadados de proveniência nos manifestos renderizados através de reescrita de YAML pós-renderização, garantindo que a saída com fonte tem as mesmas etiquetas que a saída do modo Workload. Os valores de identidade tornam-se etiquetas (app.kubernetes.io/name, aggrega.ai/component-id, aggrega.ai/provider, aggrega.ai/provider-version, aggrega.ai/environment e — quando definidos — aggrega.ai/aggregate-name, aggrega.ai/compiler-version), cada uma escrita numa forma que o Kubernetes aceita como valor de etiqueta; os valores que uma etiqueta do Kubernetes não consegue representar tornam-se anotações (aggrega.ai/recipe-uri, aggrega.ai/boundary-path, aggrega.ai/sync-wave quando a wave não é 0, e o valor literal de qualquer etiqueta cujo valor teve de ser reescrito — um Aggregate chamado imported/flow recebe a etiqueta imported-flow e a anotação imported/flow sob a mesma chave). A regra de reescrita é enunciada em well-known-annotations.md «Etiquetas de proveniência emitidas pelos fornecedores».
  6. Os ficheiros de saída ficam planos no diretório de saída da Recipe, um por recurso renderizado, com o nome <name-basis>-<kind>[-<namespace>]-<name>.yaml — a mesma base a partir da qual é derivado o nome da release descrito mais abaixo, seguida do tipo próprio do recurso, do namespace quando o tem, e do nome, cada um em minúsculas e com cada sequência de outros caracteres reduzida a um único hífen. Para um componente comum, essa base é a identidade própria do componente, que é também o que a etiqueta aggrega.ai/component-id do recurso contém; para um chart fornecido pelo autor de um anexo de Feature, continua a ser a do componente anfitrião, enquanto a etiqueta contém a identidade própria do anexo. Um documento que não tem tipo ou nome recebe, em alternativa, o nome do caminho do seu template. A estrutura de diretórios do chart é achatada: não existe nenhum subdiretório templates/ na saída renderizada, e dois templates em subdiretórios diferentes que partilham um nome de ficheiro continuam a ser dois ficheiros, porque o nome vem do recurso e não do template. Um ficheiro que o bloco artifacts: da Recipe indica não fica aqui: fica um diretório abaixo, num diretório com o nome do componente que o declarou, porque um ficheiro desse tipo recebe o nome da chave que o seu autor escreveu e não do recurso que contém — pelo que, sem esse diretório, dois componentes associados a uma mesma Recipe escreveriam um único caminho, sem que nenhum dos dois autores os pudesse separar.

O namespace em relação ao qual o chart é renderizado é lido da anotação aggrega.ai/namespace que desce em cascata a partir da fronteira e chega ao chart como o namespace da sua release; quando nenhuma fronteira declara um, o chart é renderizado em relação a default. Quando uma fronteira declara um, cada recurso com namespace que o chart renderiza sem namespace — sem metadata.namespace, ou com um escrito vazio ou null — é emitido no namespace declarado, que é onde a instalação do chart com o Helm sob esse namespace da release o coloca, e o seu ficheiro recebe o nome com o segmento do namespace exatamente como um recurso cujo template escreve o campo. Um recurso cujo template escreve um namespace mantém-no, seja qual for o namespace que indica. Um recurso com âmbito de cluster fica sem namespace. Se um tipo tem namespace é determinado pelo âmbito próprio da API do Kubernetes para um tipo que a própria API serve e, para um tipo personalizado, pelo scope que uma CustomResourceDefinition na mesma renderização declara para ele — a partir dos templates do chart ou do seu diretório crds/. Um recurso de um tipo que nenhum dos dois classifica é deixado tal como o chart o escreveu, e a compilação comunica-o, uma vez por tipo, indicando o tipo e o seu grupo de API; o mesmo acontece com um documento kind: List, cujos itens não são colocados. Quando nenhuma fronteira declara um namespace, nada é colocado e nada é comunicado: um recurso que o chart escreve sem namespace é emitido sem ele, colocado pelo que a ferramenta que o aplica selecionar.

A comunicação é um aviso na compilação, que ainda assim é concluída:

warning: node "store" (provider "helm"): resources of kind "Probe" in API group "monitoring.example.org" write no namespace and are left without one rather than placed in namespace "shop": the kind is not one the Kubernetes API serves itself, and no CustomResourceDefinition in this chart's render gives it a single scope, so whether it is namespaced is not known when the build runs, and they land wherever the tool applying the output places them

Quando o chart tem um valor que renderiza a CustomResourceDefinition do tipo, ou um que escreve o próprio namespace, defini-lo através do valuesMapping da Recipe coloca um recurso desse tipo.

A versão do Kubernetes para a qual um chart é renderizado

Os templates de um chart leem a versão do Kubernetes para a qual são renderizados como .Capabilities.KubeVersion, e muitos escolhem com base nela uma versão de API, um campo ou um mecanismo inteiro — um token de conta de serviço projetado a partir da 1.21, por exemplo, e um de primeira parte abaixo disso. A compilação não tem nenhum cluster a consultar, pelo que a versão é uma que se indica, onde a Release diz onde um componente é implementado: a anotação aggrega.ai/kubernetes-version numa fronteira, ou num componente, onde prevalece sobre a da sua fronteira, em cascata exatamente como aggrega.ai/namespace.

spec:
boundaries:
production:
annotations:
aggrega.ai/kubernetes-version: "1.31"
components:
api: {}
legacy:
annotations:
aggrega.ai/kubernetes-version: "1.28" # this component deploys to an older cluster

O valor é lido da forma como helm template --kube-version lê a sua flag, pelo que aceita as formas que essa flag aceita e um chart lê exatamente o que essa flag lhe daria: "1.31" é lido como v1.31, "v1.31.2" como v1.31.2, e o texto depois dos números permanece em .Capabilities.KubeVersion.Version tal como escrito — "1.29.3-gke.100" é lido como v1.29.3-gke.100 — enquanto .Capabilities.KubeVersion impresso na íntegra lê a versão sem ele. Um chart que compara .Capabilities.KubeVersion.Version com semverCompare lê esse sufixo como uma versão de pré-lançamento, pelo que uma restrição sem um mínimo -0, como ">=1.21", não lhe corresponde, e um valor com espaços à volta é lido com esses espaços — " 1.30 " é lido como "v 1.30 " — e falha completamente essa comparação: convém escrever a versão simples onde um chart a compara. Um valor que não é uma versão — "one.two", "latest", um único número — interrompe a compilação sob a condição de um valor que um plugin não consegue representar, indicando o valor, o componente e a sua fronteira; o chart nunca é renderizado para outra versão no seu lugar. Consulte A Kubernetes version the helm provider cannot render a chart for (Uma versão do Kubernetes para a qual o fornecedor helm não consegue renderizar um chart). Um valor vazio é tratado como não definido.

Quando nenhuma anotação indica uma versão, um chart é renderizado para a versão para a qual renderiza o helm template sem alterações da mesma release do helm, que é a versão da biblioteca cliente do Kubernetes com a qual o fornecedor é construído: um fornecedor construído com a biblioteca cliente v0.37 renderiza para o Kubernetes v1.37.0. Assim, um chart é renderizado no Aggrega tal como o helm template dos seus próprios autores o renderiza, e o valor predefinido só muda quando muda a biblioteca cliente com a qual o fornecedor é construído. Convém indicar a versão do cluster no qual se implementa sempre que for diferente: um chart renderizado para uma versão mais recente do que a que o cluster executa pode emitir uma versão de API que esse cluster não serve.

Só a versão é definida desta forma. Qualquer outra capacidade que um chart lê — .Capabilities.APIVersions e .Capabilities.HelmVersion — é a incorporada na biblioteca helm, pelo que uma API que um cluster serve a partir de uma CustomResourceDefinition instalada não é comunicada ao chart. O intervalo kubeVersion próprio de um chart no seu Chart.yaml não é comparado com a versão: helm template recusa um chart cujo intervalo exclui a versão para a qual renderiza, e a compilação renderiza-o. A anotação molda um chart renderizado a partir de uma fonte e nada mais: um Workload sintetizado e um corpo artifacts: não leem .Capabilities, e o fornecedor helm-chart passa o seu chart adiante sem o renderizar, para ser renderizado quando for instalado.

Deixar documentos renderizados de fora. Este fornecedor respeita as entradas omits: que uma Recipe ou uma FeatureRecipe declara, neste modo e em nenhum outro: um Workload sintetizado e um corpo artifacts: são renderizados sem elas. Cada documento que o chart renderiza — a partir de um template ou de um ficheiro do seu diretório crds/ — é comparado com cada entrada que se aplica à compilação, e um documento que qualquer entrada indique é deixado de fora. Uma entrada indica um documento pelas palavras que o próprio documento contém, as mesmas palavras a partir das quais são construídos o seu nome de ficheiro de saída e os seus factos de renderização: o seu kind, o seu metadata.name e, apenas quando a entrada indica um, o namespace em que o documento está — aquele que o seu template escreve, ou o namespace declarado da fronteira quando este fornecedor coloca o documento como descrito acima. Nunca é o namespace em relação ao qual o chart é apenas renderizado: sem namespace declarado, o chart é renderizado em relação a default, mas um documento cujo template não escreve nenhum namespace não está em nenhum, pelo que uma entrada que indique default não lhe corresponde. Um documento que não tem tipo ou nome não corresponde a nenhuma entrada. Os documentos deixados de fora são renderizados e depois descartados assim que o nome de cada ficheiro está definido, pelo que cada documento mantido recebe o nome e é escrito exatamente como seria sem as entradas, e um documento deixado de fora não chega a nada do que a compilação faz depois — nenhum ficheiro, nenhum nome na comparação que recusa dois contribuidores que chegam ao mesmo nome, nenhum facto de renderização que uma Feature lê, nada que seja entregue a uma etapa do pipeline. O fornecedor comunica quantos documentos corresponderam a cada entrada, e uma entrada à qual nenhum correspondeu interrompe a compilação; consulte An omits entry left out nothing the source rendered (Uma entrada omits não deixou de fora nada do que a fonte renderizou).

A release do Helm sob a qual um chart é renderizado

O fornecedor renderiza com o SDK do Helm 4, na v4.3, pelo que um chart lê o que o próprio helm template do Helm 4 lhe dá, e o mesmo chart com os mesmos valores renderiza os mesmos bytes em cada compilação. Um chart escrito e verificado com o Helm 3 pode observar estes comportamentos do Helm 4:

  • .Capabilities.HelmVersion comunica a versão do Helm 4, v4.3.
  • A versão predefinida do Kubernetes é v1.37.0, porque o Helm 4 na v4.3 é construído com a biblioteca cliente v0.37, e .Capabilities.APIVersions é o conjunto de versões de API dessa biblioteca cliente. Convém indicar a versão que o cluster executa, como descreve A versão do Kubernetes para a qual um chart é renderizado.
  • Um valor predefinido null do chart é descartado. Uma chave que o values.yaml do chart define como null — no nível superior ou dentro de uma tabela — fica ausente de .Values, a menos que os valores que a Recipe fornece a definam, pelo que hasKey a indica como em falta, toYaml omite-a, e o values.schema.json do chart é verificado em relação aos valores sem ela.
  • Um escalar de bloco mantém a sua quebra de linha final antes de ---. Um documento que termina num escalar de bloco e é seguido por outro documento do mesmo template mantém a última quebra de linha desse escalar, pelo que é escrito | em vez de |-.
  • .Chart é um mapa indexado por nome de campo. .Chart.Name, .Chart.Version, .Chart.AppVersion e os outros campos leem-se como antes, mas toYaml .Chart ou toJson .Chart.Maintainers imprimem as chaves como Name, AppVersion e assim por diante, com os campos vazios presentes, e um campo que os metadados do chart não contêm lê-se como vazio em vez de fazer falhar a renderização.
  • .Capabilities.KubeVersion.Version mantém o texto de uma versão tal como escrito, como descrito acima para a anotação aggrega.ai/kubernetes-version.
  • Um values.yaml que contém vários documentos YAML é lido na íntegra, com os documentos posteriores combinados sobre os anteriores.
  • .Files.Lines de um ficheiro vazio não devolve nenhuma linha em vez de fazer falhar a renderização.
  • As funções de template adicionadas pelo Helm 4 — mustToYaml, mustToJson, mustToToml, mustToDuration e as conversões duration… — estão disponíveis para os templates de um chart.
  • Uma dependência com dois aliases dá a cada alias a sua própria cópia das dependências dessa dependência.
  • A validação do esquema de valores aceita ou recusa de forma diferente apenas nos extremos: uma parte local de endereço de e-mail entre aspas, NaN e números infinitos, um número comparado com um não número em enum e const, e a localização comunicada para um propertyNames, um contentSchema ou um item posterior de array que falha.

Um template que o próprio motor não consegue executar — um valor lido através de uma tabela inexistente, por exemplo — é comunicado na forma do Helm 4: o ficheiro, a linha e a coluna do template numa linha própria, depois o que estava a ser executado e a mensagem, com indentação, para cada template pelo qual a falha passou. O fail ou o required próprio de um chart mantém a sua forma de uma linha execution error at (<file>:<line>:<col>): <message>, tal como um erro que uma função de template devolve.

Como é derivado o nome da release

Um chart com fonte é renderizado com um nome de release, que chega a cada template como .Release.Name. Os charts nomeiam habitualmente recursos a partir dele, pelo que um nome de release é uma identidade dentro do cluster, e não uma etiqueta na compilação.

O nome da release é a forma codificada da mesma base que serve de prefixo ao nome do ficheiro de saída do recurso renderizado, pelo que os dois são um único nome escrito duas vezes. Essa base é um instance_id para um componente comum, e a identidade composta que uma Feature anexada a uma fronteira tem. Para um chart fornecido pelo autor de um anexo de Feature, é o nome do componente anfitrião: os próprios templates do chart são renderizados com o nome da release, pelo que derivá-lo, em vez disso, do anexo mudaria o nome de recursos que o chart declara, num cluster onde já estão implementados. Esses recursos continuam a ter a própria identidade do anexo na sua etiqueta aggrega.ai/component-id — como um recurso se chama e a que pertence são aqui questões separadas, e só para um componente comum têm a mesma resposta. Um nome de release do Helm aceita um conjunto de caracteres mais restrito do que aquele que uma identidade pode conter: letras minúsculas, dígitos, hífenes e pontos, a começar e a terminar com uma letra minúscula ou um dígito, até 53 caracteres. Em vez de substituir um carácter que o destino não aceita, a derivação escreve-o por extenso, pelo que duas identidades de componente que diferem apenas na pontuação ou em maiúsculas e minúsculas chegam sempre a dois nomes de release.

  • Uma letra minúscula e um dígito são mantidos exatamente como foram escritos.
  • Um hífen é mantido tal como foi escrito sempre que o carácter que o segue é mantido diretamente e não é um z minúsculo. Um hífen seguido de um z minúsculo abre uma sequência de escape, pelo que um hífen escrito nessa posição é ele próprio escrito por extenso — api-zone torna-se api-zhzone, e é isso que permite ler de volta qualquer nome sem adivinhar. Um hífen sem nada a seguir é escrito por extenso pela mesma razão, pelo que db- dá db-zh.
  • Qualquer outro carácter é escrito como -z seguido de uma letra que o identifica: d para um ponto, u para um sublinhado, s para um separador de caminho, h para um hífen que a regra acima não mantém. Tudo o resto — incluindo uma letra maiúscula — é escrito como x e o ponto de código hexadecimal de seis dígitos do carácter, e um byte que não inicia nenhum carácter como b e o seu próprio valor de dois dígitos.
  • Um valor vazio é escrito -ze, que nenhum valor não vazio pode produzir.

Um ponto é escrito por extenso em vez de mantido, embora o Helm aceite um ponto num nome de release, porque o Helm exige uma letra minúscula ou um dígito de cada lado de um ponto e a derivação coloca hífenes próprios.

Como duas Features anexadas a um mesmo componente são ambas renderizadas com o nome da release desse componente, dois charts que nomeiam cada um um recurso a partir de .Release.Name emitem dois recursos com um mesmo nome. Este fornecedor comunica o nome que cada recurso produzido pela sua própria renderização tem, delimitado ao tipo desse recurso e, para um tipo que o cluster mantém num namespace, ao seu namespace, e a compilação recusa dois contribuidores que chegam a um desses nomes em vez de emitir uma saída em que aplicar ambos deixa apenas o último — consulte ../errors/fatal-halts.md «The same name is derived more than once inside the output (O mesmo nome é derivado mais de uma vez dentro da saída)». Um tipo que o cluster mantém fora de qualquer namespace — um ClusterRole, uma CustomResourceDefinition ou um tipo personalizado que uma CustomResourceDefinition na mesma renderização declara com o âmbito Cluster — é delimitado apenas ao seu tipo, classificado exatamente como o classifica a colocação em namespaces descrita acima, pelo que dois componentes de uma mesma saída que escrevem cada um um objeto desses com um mesmo nome são recusados mesmo quando a Release os coloca em namespaces diferentes. A correção é compor o nome, e a coordenada de que precisa depende da disposição. Dois anexos num mesmo componente já partilham o anfitrião, pelo que é o anexo que tem de chegar ao template: passe .attachment_name para o chart através do valuesMapping: da FeatureRecipe e defina-o naquele dos próprios valores do chart a partir do qual são construídos os nomes dos seus recursos. Um mesmo chart anexado a dois componentes é o caso inverso — o nome da release já difere por anfitrião, pelo que um recurso nomeado a partir de .Release.Name tem um nome próprio em cada um deles, enquanto um nome literal não. Uma FeatureRecipe que entrega os seus recursos através de artifacts: é comunicada nos mesmos termos: este fornecedor lê o nome que cada documento emitido tem, quer esse documento venha de um template de chart, quer de um corpo de artefactos, pelo que um nome literal num corpo desses anexado a dois componentes também interrompe a compilação. Um corpo de artefactos é um template, pelo que o nome deve ser composto a partir de .context.rendered_name — o nome da release do anfitrião, que difere por anfitrião e é escrito nos caracteres que um nome do Kubernetes permite — e de .attachment_name onde tem de ser distinto por anfitrião; num anfitrião que coloca sozinho um conjunto de artefactos, que não comunica nenhum nome de release, deve ser composto, em vez disso, a partir de .context.instance_id. Nem todos os nomes são comunicados, pelo que uma compilação que não é interrompida não comparou tudo o que a sua saída acabará por ter. O que é mais provável encontrar ao escrever um chart é um recurso que declara generateName, cujo nome fica a cargo do cluster completar e que, por isso, ainda não tem nada a comparar. A página indicada acima contém o conjunto completo.

Assim, um instance_id api dá o nome de release api, data.main-db dá data-zdmain-db, e db_host dá db-zuhost. Uma identidade formada apenas por letras minúsculas, dígitos e hífenes que a derivação mantém aparece exatamente tal como foi escrita. Uma entrada idêntica produz sempre o nome idêntico.

Duas das condições do Helm são propriedades da base, e não da derivação: um nome de release tem de começar por uma letra minúscula ou um dígito, e tem de ter no máximo 53 caracteres. Uma base cujo primeiro carácter é escrito por extenso começa o seu nome pelo hífen com que se abre cada sequência de escape, e uma que contém caracteres escritos por extenso fica, uma vez codificada, mais longa do que foi escrita. A compilação consulta este fornecedor sobre ambas, e age de acordo com a resposta no momento da compilação em vez de deixar a recusa ao cluster no momento da aplicação — consulte ../errors/fatal-halts.md «The target will not accept a name derived from an authored identity (O destino não aceita um nome derivado de uma identidade escrita)». O que faz com a resposta depende de quem escreveu a base. Um nome escrito pelo autor é recusado em vez de alterado, e a recusa indica o campo que escreveu e o limite de que dispõe; um nome que Aggrega compôs é encurtado até que este fornecedor o aceite.

O cluster sujeita os recursos nomeados a partir de um componente a uma regra mais rigorosa do que as do Helm: o nome de um Service tem de começar por uma letra, enquanto um nome de release pode começar por um dígito. Um chart nomeia habitualmente os seus Services a partir do nome da release, e os Services de uma carga de trabalho sintetizada também começam por ele, pelo que este fornecedor também recusa um nome de componente que comece por um dígito, comunicando-o como um Service name que o destino não pode usar. Nenhum comprimento corrige um primeiro carácter, pelo que essa recusa não indica nenhum. Convém, por isso, começar um instance_id por uma letra minúscula e mantê-lo suficientemente curto para que a sua forma codificada ainda caiba.

Alterar a base a partir da qual um nome de release é derivado muda o nome dos recursos do cluster que um chart nomeia a partir de .Release.Name, e de cada recurso que este fornecedor sintetiza para o componente, e o Kubernetes não muda o nome de um recurso no local. A ferramenta que aplica a saída cria o recurso com o novo nome e remove o que tem o nome antigo, o que, para recursos com estado, significa que o armazenamento associado ao nome antigo é libertado. Uma alteração destas deve ser tratada como uma substituição a planear — com drenagem, migração ou uma janela agendada — e não como uma atualização a implementar.

Modo Workload (sintetizado)

Uma Recipe com workload: (em linha ou carregado através de $import:) sintetiza recursos do Kubernetes a partir da intenção abstrata do Workload. O esquema do Workload está documentado em entities/workload.md; esta secção abrange o que o fornecedor helm emite.

Para cada nó:

  • Um objeto controlador escolhido pelo form do Workload: stateless (e o valor predefinido) emite um Deployment, stateful um StatefulSet, daemon um DaemonSet, task um Job, scheduled um CronJob cujo spec.schedule é o campo schedule do Workload (uma expressão cron de 5 campos ou uma macro @); uma carga de trabalho scheduled sem agendamento, ou com um mal formado, interrompe a compilação de forma explícita. Uma carga de trabalho scheduled que declara suspend: true emite o seu CronJob com spec.suspend: true, pelo que nenhuma execução arranca a partir do agendamento até ser retomada, enquanto um Job pode continuar a ser criado manualmente a partir do CronJob; uma que não o declara não emite nenhuma chave suspend. O Deployment e o StatefulSet têm o número de réplicas; DaemonSet, Job e CronJob não têm nenhum. Um Workload stateful exige exatamente um Service type: Headless declarado no Workload para governar o StatefulSet; o fornecedor liga o serviceName do StatefulSet ao nome renderizado desse Service, e a compilação é interrompida se não for declarado nenhum Service headless (ou se for declarado mais de um). Um volume persistentTemplate é um complemento de form: stateful — declarar um em qualquer outra forma interrompe a compilação com uma mensagem que indica a correção.
  • Um Service por cada entrada services: declarada no Workload, expondo as portas com nome que a especificação do serviço lista. O type da entrada passa a ser o tipo do Service — ClusterIP, NodePort e LoadBalancer literalmente, e Headless como um Service ClusterIP com clusterIP: None. Uma entrada Loopback interrompe, em vez disso, a compilação, indicando o nó e o serviço: um Service do Kubernetes não tem nenhum tipo que se associe ao endereço de loopback de um host, e os endereços de nó em que um Service NodePort escuta são uma definição de todo o cluster, pelo que a entrada é recusada em vez de renderizada com um alcance que não pediu. Consulte A service type the helm provider cannot render (Um tipo de serviço que o fornecedor helm não consegue renderizar).
  • Um PersistentVolumeClaim por cada volume persistent, dimensionado e configurado a partir da especificação do volume. Um volume persistentTemplate não emite nenhuma claim autónoma: passa a ser uma entrada volumeClaimTemplates dentro da própria especificação do StatefulSet, e é por isso que é um complemento de form: stateful.

Nomes dos recursos. Cada recurso que este modo emite para um componente é nomeado a partir do nome da release do componente — o mesmo nome com que um chart com fonte é renderizado, derivado como descreve Como é derivado o nome da release — e o fornecedor comunica esse nome à compilação como {{ .context.rendered_name }}. O objeto controlador tem o próprio nome da release; cada Service é <release name>-<service key>; cada claim autónoma é <release name>-<volume>, e o volume do pod referencia exatamente essa claim; um secret entregue como ficheiro é montado a partir de um volume do pod chamado <release name>-secret-<slot>, com o slot escrito no alfabeto que o cluster aceita, tal como o nome da release — assim, um slot server_certificate é montado a partir de <release name>-secret-server-zucertificate, e um slot lido através de uma ligação tem o ponto a seguir ao nome da ligação escrito da mesma forma; o serviceName de um StatefulSet é o nome do Service headless que emite; e um Workload exposto apenas por nome externo emite um único Service com o nome da release. Assim, um componente api emite um Deployment api e um Service default api-default, e um componente my_api emite my-zuapi e my-zuapi-default — nomes que o cluster aceita, onde a identidade tal como foi escrita não seria aceite. Uma Recipe que publica o endereço de um desses Services constrói-o a partir de {{ .context.rendered_name }}, como mostra ../templates/rendered-resource-names.md; para um componente cujo nome não contém sublinhado nem letra maiúscula, o nome da release é igual ao seu instance_id, pelo que os seus nomes se leem exatamente como a identidade. Uma carga de trabalho que um anexo de Feature sintetiza é a única exceção: é nomeada a partir da própria identidade composta do anexo — o valor que a sua etiqueta aggrega.ai/component-id tem — porque o anexo é renderizado com o seu componente anfitrião, e um nome de release derivado aí nomearia a carga de trabalho do anexo a partir do anfitrião e colidiria com a do próprio anfitrião. Essa identidade nunca contém uma letra maiúscula: uma maiúscula no nome do anfitrião ou no do anexo é escrita por extenso como sequência de escape, tal como qualquer outro carácter que um nome de recurso recusa, pelo que um anexo worker num componente myApi emite um Deployment cfr--my-zx000041pi--worker e um Service default cfr--my-zx000041pi--worker-default, e cada nome que a carga de trabalho tem é um que o cluster aceita.

Comprimentos de nome que dependem do Workload. Dois destes nomes estão sujeitos, no cluster, a limites próprios, e a compilação verifica ambos assim que o Workload é resolvido, em vez de deixar a recusa para o cluster no momento da aplicação. Um nome de CronJob tem no máximo 52 caracteres, menos do que os outros nomes do cluster porque o controlador nomeia o Job de cada execução segundo o CronJob, acrescentando-lhe um sufixo; só é verificado para um Workload scheduled. Cada nome de Service, <release name>-<service key>, tem no máximo 63 caracteres. Para além de qualquer dos limites, o que acontece depende de quem escreveu o nome, exatamente como para o nome da release: um nome de componente escrito pelo utilizador é recusado, com a compilação interrompida na chave spec.components que escreveu, indicando o tipo de nome, o seu comprimento e o orçamento que o seu nome tem — ver ../errors/fatal-halts.md «The target will not accept a name derived from an authored identity (O destino não aceitará um nome derivado de uma identidade escrita pelo autor)»; uma identidade composta, como aquela segundo a qual é nomeado o workload de um anexo de Feature, é encurtada até que todos os nomes caibam. Um nome de Service é construído a partir do nome do componente e de uma chave que o workload declara — na Recipe ou numa FeatureRecipe —, pelo que uma recusa indica essa chave e onde o workload a declara, spec.workload.services.<key>; uma chave que não deixe espaço para nenhum nome de componente tem de ser ela própria encurtada. Assim, um componente com um Workload scheduled pode ter um nome codificado de até 52 caracteres, e um componente web pode ter chaves de Service de até 59. Uma Feature anexada a uma fronteira inteira tem a sua identidade fixada antes de o seu Workload ser resolvido, porque o local onde a sua saída é montada pode depender dessa identidade, pelo que nenhum dos limites é verificado para os recursos que sintetiza.

Cada recurso emitido tem o conjunto completo de etiquetas e anotações de proveniência de Aggrega, mais um par de seletores (app: <instance_id>) ligado entre o Deployment/StatefulSet e os seus Services. Um valor de etiqueta admite a identidade tal como foi escrita, pelo que o seletor a mantém enquanto os nomes acima recebem o nome da release. Os nomes dos contentores no Deployment renderizado são as chaves de contentor do Workload com os caracteres . e _ substituídos por - (sanitização de nomes do Kubernetes).

Transporte das portas. Uma porta de contentor que declara um transporte emite-o literalmente como protocol: no containerPort renderizado, e cada porta de Service que indica essa porta de contentor tem o mesmo valor — o transporte é declarado uma única vez, na porta de contentor, pelo que a exposição não pode discordar dele. Uma porta que não declara nenhum transporte não emite nenhuma chave protocol em nenhum dos dois recursos, deixando em vigor a predefinição do cluster. Os três valores que o Workload admite (TCP, UDP, SCTP) são emitidos literalmente; o helm não precisa de nenhuma degradação, uma vez que o Kubernetes expressa cada um deles diretamente.

Execução na rede do nó. Um Workload que declara hostNetwork: true emite hostNetwork: true na especificação do pod renderizada, pelo que o pod é executado no próprio namespace de rede do nó e as portas que os seus contentores abrem ficam acessíveis nos endereços do nó. O Kubernetes expressa a escolha diretamente, pelo que nada é degradado. A declaração chega à especificação do pod e a nada mais: não acrescenta, não remove e não reescreve nenhuma porta, e os Services emitidos são idênticos com e sem ela. Um Workload que não a declara não emite nenhuma chave hostNetwork.

Quantidades de recursos. Cada quantidade que o fornecedor copia para os manifestos é emitida literalmente, e cada uma é verificada primeiro em relação à forma de quantidade descrita em Workload → Quantidades de recursos: os valores resources.requests e resources.limits de cada contentor e de cada contentor de inicialização — cpu, memory e cada recurso estendido como nvidia.com/gpu — e ephemeral.sizeLimit, persistent.size e persistentTemplate.size de cada volume. A verificação é executada sobre o Workload tal como os templates da Recipe o avaliaram, pelo que um valor que chegou através de infra ou de um parâmetro da Release é julgado pelo resultado da sua renderização. Um valor fora da forma interrompe a compilação com um erro TRANSLATION_ERROR que indica o nó, o caminho do campo no Workload e o valor — por exemplo containers.main.resources.requests.cpu: "lots" is not a quantity: it does not begin with a number — onde, de outro modo, o chart seria gerado sem erros e recusado pelo cluster na instalação. Um cpu, memory ou sizeLimit deixado vazio é omitido dos manifestos e, por isso, não é verificado; um valor de recurso estendido ou um tamanho persistente deixado vazio seria emitido na mesma, pelo que é recusado. A verificação julga apenas a forma: se o cluster consegue agendar a quantidade não é algo que o fornecedor possa saber no momento da compilação.

A nomeação dos ficheiros de saída tem duas formas. O objeto controlador é nomeado a partir do nome da release e do seu tipo — <release name>-deployment.yaml, <release name>-statefulset.yaml, <release name>-daemonset.yaml, <release name>-job.yaml, <release name>-cronjob.yaml. Um ficheiro por recurso é nomeado a partir do recurso que contém, com o tipo no fim: <release name>-<svcName>-service.yaml e <release name>-<volName>-pvc.yaml, cada um retirado do próprio metadata.name desse recurso segundo a convenção de nomes sintetizados em entities/workload.md. Um Workload exposto apenas por nome externo emite <release name>-service.yaml, uma vez que não há nenhuma chave de serviço a incluir.

Factos de renderização

Além dos ficheiros que renderiza, este fornecedor comunica quatro factos de renderização sobre cada nó: o que os documentos do Kubernetes que emitiu dizem sobre os seus pods, os seus seletores, as suas portas e o namespace em que cada um é emitido. Uma FeatureRecipe anexada ao componente lê os próprios factos do componente em .context.render_facts; uma que define readsCallerRenderFacts: true lê também, em cada entrada de .context.used_by, os factos de um componente que se liga ao seu anfitrião, e uma que define readsTargetRenderFacts: true lê, em cada entrada de .context.uses, os factos de um componente ao qual o seu anfitrião está ligado. É assim que uma Feature pode indicar os pods dos componentes que chamam o seu anfitrião, ou dos componentes que o seu anfitrião alcança — uma política de rede que admita exatamente esses, por exemplo — a partir do que as respetivas renderizações efetivamente emitiram, sem que ninguém repita uma etiqueta à mão. Os nomes e as entradas abaixo são o contrato deste fornecedor.

FactoUma entrada porCada entrada contém
pod_template_labelstemplate de pod emitido: o spec.template de um Deployment, StatefulSet, DaemonSet, ReplicaSet ou Job, o template de job de um CronJob, e um Pod isolado, que é o seu próprio templatekind, name e namespace do recurso que contém o template; labels, as etiquetas do template
controller_selectorsDeployment, StatefulSet, DaemonSet, ReplicaSet, Job e CronJob emitidokind, name, namespace; match_labels, os matchLabels do seu seletor
service_selectorsService emitidoname, namespace; selector, as etiquetas para as quais envia tráfego
container_portscontentor de um template de pod que declara uma lista ports, incluindo os contentores de inicializaçãokind, name e namespace do recurso que contém o template; container, o nome do contentor; ports, uma entrada por porta com o seu name, container_port e protocol

Como se leem os factos:

  • Cada facto é uma lista. Um template percorre sempre um facto, mesmo quando este contém uma única entrada; não existe um valor único a ler isoladamente.
  • Os quatro, em cada renderização. Cada um é comunicado sempre que este fornecedor renderiza um nó, como uma lista vazia quando a renderização não emitiu nada do que descreve — um componente cujo chart emite apenas um ConfigMap comunica quatro listas vazias. A renderização de outro fornecedor não comunica nenhum destes nomes, e um nome que ninguém comunicou lê-se como nada.
  • Lidos a partir do que foi emitido, em todos os caminhos. Os factos vêm dos documentos que a renderização emitiu, seja qual for o modo que os produziu: os manifestos renderizados de um chart, os de um Workload sintetizado e os manifestos que um autor colocou através de artifacts:, que comunicam exatamente o que esses manifestos contêm. São lidos na mesma passagem, sobre os mesmos documentos, que os nomes de recursos que este fornecedor comunica para a verificação de nomes duplicados da compilação. As próprias etiquetas de proveniência de um recurso fazem parte do que este contém, pelo que as labels de um Pod isolado as incluem; o template de pod de um chart ou de um artefacto mantém as etiquetas que o seu autor escreveu.
  • As entradas podem vir da própria renderização do componente e das renderizações das suas Features. Um componente pode ser renderizado por mais de uma chamada — um chart e uma colocação artifacts:, por exemplo — e as listas que um nome recebe dessas chamadas são unidas numa só, pela ordem em que as chamadas foram executadas. Em .context.used_by e .context.uses, os factos do componente na outra extremidade de uma ligação reúnem também o que as Features anexadas a ele renderizaram, depois dos seus próprios; .context.render_facts contém apenas a própria renderização do componente.
  • Pela ordem de emissão. As entradas seguem a ordem pela qual a renderização emitiu os recursos. Um mapa de etiquetas é um mapa com chaves como qualquer outro no contexto, pelo que um template que percorre um encontra as suas chaves pela ordem das chaves.
  • O que um documento deixa de fora, a sua entrada deixa de fora. Um recurso nomeado através de generateName não tem name; um recurso que não escreve nenhum metadata.namespace não tem namespace, e também não o tem um que o escreve vazio ou null, o que também não indica nenhum namespace; um controlador escrito sem matchLabels — um Job que se baseia no seletor que o cluster gera — não tem match_labels; um Service sem seletor não tem selector; uma porta sem nome ou sem protocolo não tem nenhum dos dois. Qualquer outra parte escrita vazia é comunicada vazia. protocol só é comunicado onde o documento escreve um, pelo que um template que precise dele escreve por si próprio a predefinição do próprio cluster, TCP. container_port é um número sempre que o documento escreve um.
  • namespace é o que o documento escreve, nunca uma suposição. É o próprio metadata.namespace do recurso — para um template de pod, o do recurso que o contém, que é onde os seus pods são executados; um namespace escrito dentro do próprio template de pod não é lido. Um Workload sintetizado escreve o namespace que a sua fronteira declara em cada recurso que emite, pelo que as suas entradas contêm esse namespace. As entradas de um chart contêm o que os seus documentos emitidos escrevem: quando uma fronteira declara um namespace, esse namespace — quer os templates do chart o projetem, quer o fornecedor coloque o recurso nele (consulte Modo com fonte) — a menos que um template fixe um próprio, que a entrada contém em vez disso; quando nenhum é declarado, o namespace da release, default, quando os templates o projetam, e nada quando não escrevem nenhum. Quando nada é escrito, a entrada não contém nenhum namespace em vez da predefinição da fronteira ou do cluster, porque um recurso desse tipo vai parar onde a ferramenta que aplica a saída o colocar, o que não é conhecido quando a compilação é executada. Um template distingue os dois casos com optional: {{ optional . "namespace" "" }} é vazio exatamente onde o documento não escreveu nenhum, pelo que uma Feature que coloca algo junto dos pods de um componente consegue distinguir um componente cujo namespace dos pods é conhecido de um cujo namespace não é.
  • Reconhecidos por tipo e grupo de API. Pod e Service são lidos no grupo core, os quatro controladores em apps, Job e CronJob em batch, em qualquer versão do grupo. Um recurso personalizado de outro grupo que por acaso tenha um destes nomes de tipo não é lido como tal. As matchExpressions de um seletor não são comunicadas, nem um recurso envolvido num documento kind: List ou um valor escrito através de uma chave de fusão do YAML.

O que os factos não conseguem ver. Descrevem os documentos que a compilação emite, e nada do que o cluster cria mais tarde. Os pods que um controlador cria em tempo de execução a partir de um recurso personalizado — o cluster de base de dados de um operador, por exemplo — não aparecem em nenhum documento emitido, pelo que estão ausentes por construção; o mesmo acontece com qualquer etiqueta que um controlador de admissão de mutação acrescente quando os manifestos são aplicados. Uma Feature que tenha de admitir esses pods obtém as respetivas etiquetas da própria documentação do recurso personalizado, como faria um autor sem estes factos.

Uma FeatureRecipe que admite nos pods do seu anfitrião exatamente os pods dos componentes que o chamam, selecionando os próprios pods do anfitrião pelo seletor do controlador do anfitrião:

apiVersion: aggrega.ai/v1beta1
kind: FeatureRecipe
metadata:
name: admit-callers
version: 1.0.0
spec:
capability: helm
implements: example/admit-callers:1.0.0
readsCallerRenderFacts: true
artifacts:
allow-callers.yaml: |
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: {{ .context.rendered_name }}-allow-callers
spec:
podSelector:
matchLabels:
{{- range .context.render_facts.controller_selectors }}
{{- range $k, $v := .match_labels }}
{{ $k }}: {{ toJson $v }}
{{- end }}
{{- end }}
policyTypes:
- Ingress
ingress:
- from:
{{- range .context.used_by }}
{{- range .render_facts.pod_template_labels }}
- podSelector:
matchLabels:
{{- range $k, $v := .labels }}
{{ $k }}: {{ toJson $v }}
{{- end }}
{{- end }}
{{- end }}

Para um anfitrião api chamado por um componente web cujo Workload este fornecedor sintetizou, a política seleciona app: "api" e admite um podSelector que contém cada etiqueta do template de pod de web — as mesmas etiquetas que o spec.template.metadata.labels do seu Deployment emitido contém. Como a FeatureRecipe define a chave, o seu anexo é renderizado depois de todos os componentes terem sido renderizados, pelo que os factos estão lá seja qual for, entre api e web, aquele que a compilação alcança primeiro; sem a chave, um template que lê render_facts em .context.used_by interrompe a compilação antes de qualquer coisa ser renderizada.

Um podSelector no from de uma política corresponde a pods no próprio namespace da política, pelo que a política acima admite chamadores emitidos no namespace em que é aplicada. Um chamador cujas entradas contêm outro namespace é admitido combinando o seu podSelector com um namespaceSelector na etiqueta kubernetes.io/metadata.name desse namespace, que o Kubernetes define em cada namespace.

Particularidades específicas do Provider

  • As transferências de charts usam apenas os processadores integrados do Helm. Um chart obtido de um repositório Helm é transferido com os próprios processadores integrados http e https do Helm. Um plugin de transferência do Helm — um instalado para o comando helm, ou um que esteja no diretório a partir do qual a compilação é executada — nunca é consultado, pelo que o que está nesse diretório não pode alterar a forma como um chart é obtido.

  • Injeção da proveniência. Os caminhos com fonte e sintetizado convergem no mesmo conjunto de etiquetas e anotações; as renderizações com fonte injetam-nas através de reescrita de YAML pós-renderização (depois de o SDK do Helm já ter renderizado), pelo que os autores de charts não precisam de passar as etiquetas de Aggrega pelos seus próprios templates.

  • Ordem do ambiente — primeiro as entradas lidas de um Secret. A lista env de um contentor sintetizado contém dois tipos de entrada: cada entrada attachments entregue as: env lê o seu valor de um Secret através de valueFrom.secretKeyRef, e cada entrada variables contém um value simples. O fornecedor escreve primeiro cada entrada lida de um Secret e depois cada variável simples, cada tipo pela ordem em que foi escrito, e lista as fontes envFrom em separado sob envFrom. O Kubernetes expande uma referência $(NAME) num valor de env a partir das entradas listadas antes dela no mesmo contentor, nunca a partir de uma listada depois, pelo que esta ordem permite que uma variável simples componha por referência um valor lido de um Secret enquanto o próprio segredo permanece no Secret:

    containers:
    api:
    image: "api:1.0"
    variables:
    DATABASE_URL: "postgres://app:$(DB_PASSWORD)@db:5432/app"
    attachments:
    DB_PASSWORD: { from: db-credentials, as: env }

    O contentor renderizado lista DB_PASSWORD antes de DATABASE_URL, pelo que o processo recebe o URL com a palavra-passe no sítio. Uma variável pode também referenciar qualquer variável escrita antes dela, o que mantém significativa a ordem de escrita dentro de variables. Os contentores de inicialização seguem a mesma ordem. Um contentor que indica um mesmo nome simultaneamente como entrada variables e como entrada attachments entregue as: env interrompe a compilação em vez de escrever as duas entradas, porque então seria apenas esta ordem a decidir que valor o processo vê (consulte A container gives one environment variable two values (Um contentor dá dois valores a uma mesma variável de ambiente)).

  • Cascata do namespace — os dois modos chegam ao recurso de forma diferente. Ambos leem aggrega.ai/namespace da cascata de anotações da fronteira, e nenhum deles inventa um namespace quando nenhuma fronteira declara um. No modo sintetizado, o fornecedor escreve metadata.namespace diretamente, e omite o campo por completo quando a cascata não produz nenhum valor. No modo com fonte, o fornecedor passa o valor como namespace da release do chart — default quando a cascata não produz nenhum — e o próprio template do chart decide se o projeta; quando é declarado um namespace, o fornecedor escreve-o depois em cada recurso com namespace que o chart renderizou sem um (consulte Modo com fonte). Assim, com um namespace declarado, os dois modos colocam nele cada recurso com namespace — à exceção de um namespace que um chart fixa por si próprio e de um tipo que o fornecedor não consegue classificar. Sem nenhum declarado, separam-se: um chart que projeta o namespace da release coloca os seus recursos em default, onde a saída sintetizada não escreve nenhum, e um chart que não escreve nenhum namespace não os coloca em nenhum, pelo que vão parar onde a ferramenta que aplica os manifestos os puser. Os charts locais que as FeatureRecipes da biblioteca padrão contêm leem, em alternativa, o valor da cascata diretamente através do seu valuesMapping: isso permite-lhes omitir o campo quando nenhuma fronteira declara um namespace, em linha com a saída sintetizada, o que o namespace da release, por si só, não consegue exprimir, porque nunca é vazio.

Exemplos práticos

Modo com fonte — Recipe que aponta para um chart copiado localmente:

apiVersion: aggrega.ai/v1beta1
kind: Recipe
metadata:
name: api-server-helm
version: 1.0.0
spec:
capability: helm
implements: core/api-server
source: ./vendor/charts/api-server
valuesMapping: |
image: "{{ .values.image }}"
replicaCount: {{ optional .infra `replicas` 2 }}
service:
type: ClusterIP
port: {{ .values.port }}
env:
LOG_LEVEL: "{{ optional .values `log_level` "info" }}"

Modo Workload — Recipe que declara um Workload em linha:

apiVersion: aggrega.ai/v1beta1
kind: Recipe
metadata:
name: api-server-workload
version: 1.0.0
spec:
capability: helm
implements: core/api-server
workload: |
apiVersion: aggrega.ai/v1beta1
kind: Workload
replicas: {{ optional .infra `replicas` 2 }}
containers:
api:
image: "{{ .values.image }}"
ports:
web: {{ .values.port }}
services:
svc:
type: ClusterIP
ports:
web: {{ .values.port }}

Referências cruzadas