
Kubernetes é geralmente descrito como um sistema declarativo. Na maioria das vezes você trabalha com YAML que define como deve ser o estado final do sistema. O Kubernetes também suporta APIs imperativas, onde você emite um comando e obtém uma saída imediata.
Neste artigo, exploraremos as diferenças entre essas duas formas de gerenciamento de objetos. As chances são de que você já tenha usado ambos, mesmo que não reconheça os termos.
Declarativo x Imperativo: Definições
Primeiro, é útil examinar a terminologia.
Algo que é declarativo faz uma declaração do resultado final, indicando a intenção, mas não o processo para alcançá-lo. No Kubernetes, isso está dizendo "Deve haver um ReplicaSet com três pods".
Um imperativo funciona como um comando. Enquanto um declarativo é passivo, os imperativos são ativos e imediatos: “Crie um ReplicaSet com três pods”.
O ecossistema Kubernetes fornece mecanismos para interagir com seu cluster em qualquer uma dessas formas. As abordagens imperativas são atendidas por comandos CLI e arquivos YAML individuais. A configuração declarativa é facilitada usando diretórios de arquivos que são combinados na representação final do recurso.
Gerenciando Objetos Imperativamente
Aqui está um exemplo de como criar uma implantação de forma imperativa:
kubectl create deployment my-deployment --image my-image:latest
Você está instruindo o Kubernetes a adicionar imediatamente uma nova implantação ao seu cluster. O comando inclui um único verbo (create) e o nome do tipo de recurso com o qual você está trabalhando (deployment).
Você também pode escrever um arquivo YAML e aplicá-lo imperativamente usando o create comando:
apiVersion: apps/v1 kind: Deployment spec: replicas: 3 selector: matchLabels: app: example template: metadata: labels: app: example spec: # ...
kubectl create -f deployment.yml
Como antes, você está emitindo um comando imediato por meio de um verbo ativo. O Kubernetes pegará a configuração do seu arquivo e criará os recursos correspondentes no cluster. Se você precisar atualizar um recurso, deverá modificar seu YAML e usar o replace comando para efetuar a alteração:
kubectl replace -f deployment.yml
Esta operação irá remover a especificação de qualquer recurso existente e substitua-o pela versão em seu arquivo de configuração. Isso é transmitido pelo nome do replace comando. Isso significa que você perderá todas as alterações feitas em seus objetos ativos que não estiverem presentes em seu YAML.
Quando o Kubernetes está consumindo comandos imperativos, ele precisa ser informado exatamente o que fazer. Conseqüentemente, não há como aplicar seletivamente apenas as partes alteradas de seu YAML. Para isso, você precisará mudar para operações declarativas.
Tentando o Gerenciamento Declarativo
O gerenciamento declarativo só está disponível quando você usa arquivos de configuração YAML. Não existe comando declarativo. Ao usar operações declarativas, você não diz ao Kubernetes o que fazer fornecendo um verbo (create/replace). Em vez disso, você usa o único apply comande e confie no Kubernetes para elaborar as ações a serem executadas.
kubectl apply -f deployment.yml
Continuando o exemplo de implantação acima, aplicando o YAML acima para seu cluster inicialmente agiria da mesma forma que um imperativo create comando. Nenhum recurso correspondente existirá para começar, então o Kubernetes deve criar um novo.
Você poderia então alterar o replicas campo para 5 e repita o apply comando. Desta vez, o Kubernetes corresponderá ao recurso existente, detectará a alteração em seu YAML e dimensionará a implantação sem afetar nenhum outro campo.
Usando a abordagem imperativa, você precisaria usar o kubectl scale comando para alterar a contagem de réplicas de uma implantação existente. Se você modificou o YAML usado com kubectl create, você precisaria executar kubectl replace – mas isso substituiria toda a implantação spec, em vez de simplesmente dimensionar sua contagem de réplicas.
Declarativo vs Imperativo: Comparando os Trade-offs
As operações imperativas são simples de entender e raciocinar. Cada ação é expressa como um verbo com uma consequência claramente definida. Por esse motivo, a maioria das pessoas começará suas primeiras interações com o Kubernetes usando comandos imperativos que podem ser mapeados livremente para outras tecnologias, como o Docker.
O gerenciamento declarativo expõe o verdadeiro poder do Kubernetes. Você declara como deve ser o estado final e deixa o Kubernetes fazer o resto. Cada comando tem a mesma ação imperativa – apply esse conjunto de arquivos YAML e progride o cluster para o estado que eles definem.
O gerenciamento declarativo é ideal para implantações automatizadas. Você não precisa gastar tempo criando um conjunto de instruções de migração sempre que atualizar um recurso. Em vez disso, ajuste seu YAML para que ele produza objetos configurados corretamente se eles forem criados novamente no momento. O Kubernetes lidará com atualizações de objetos existentes para que também correspondam ao novo estado.
Os arquivos YAML declarativos são fáceis de versionar, revisar e mesclar como parte de seu sistema de controle de origem. Se você usar comandos imperativos, não terá como rastrear como seu cluster evoluiu e será mais complicado reverter para um estado anterior. Ao contrário das operações imperativas, as atualizações declarativas não substituem o objeto inteiro, portanto, você manterá as alterações feitas por meio de outros mecanismos, independentemente de seus arquivos YAML.
No entanto, a gestão imperativa retém algumas vantagens. A configuração declarativa adiciona camadas de complexidade e pode ser mais difícil de depurar, principalmente quando o Kubernetes seleciona um curso de ação inesperado. Cada alteração resulta em uma operação de mesclagem e correção para alinhar seus objetos com o estado desejado. Com o modelo imperativo, o que você pede é o que você obterá, a menos que ocorra um erro.
Como sempre, quando duas abordagens são oferecidas, ambas as estratégias são úteis e a escolha deve depender do contexto. Para clusters de produção que hospedam aplicativos ativos com alterações frequentes, você provavelmente deseja arquivos YAML declarativos com versão. Se você estiver criando rapidamente novos contêineres em um cluster de desenvolvimento, os comandos imperativos economizarão tempo e serão mais fáceis de trabalhar.
Conclusão
O gerenciamento declarativo e imperativo são duas maneiras de interagir com seu cluster Kubernetes e seus recursos. O Kubectl tem suporte integrado para ambas as estratégias, mas as técnicas não devem ser misturadas por objeto. Se você criar um objeto declarativamente, ele deve ser gerenciado dessa maneira durante toda a sua vida – usar comandos imperativos com ele pode levar a um comportamento inesperado.
As operações imperativas afetam os objetos ativos em seu cluster. Você define um verbo, recurso e configuração por meio de argumentos e sinalizadores de comando. O gerenciamento declarativo é baseado em alterações nos arquivos de configuração locais que o Kubectl diferencia e aplica ao cluster por meio de patches quando você usa o kubectl diff e kubectl apply comandos.
Fonte Adicione ao Google Notícias



