
O Kubernetes é um sistema distribuído projetado para dimensionar réplicas de seus serviços em vários ambientes físicos. Em muitos casos, isso funciona bem fora da caixa. O agendador do Kubernetes coloca automaticamente seus pods (instâncias de contêiner) em nós (máquinas de trabalho) que têm recursos suficientes para suportá-los.
Apesar de seus melhores esforços, às vezes o agendador não seleciona um plano com o qual você concorda. Você pode querer que os pods sejam colocados se eles estiverem se comunicando regularmente pela rede; como alternativa, alguns pods com uso intensivo de computação podem ser melhor alocados para separar nós sempre que possível.
O Kubernetes possui vários mecanismos que permitem orientar o processo de tomada de decisão do agendador para que os Pods acabem em nós específicos. Neste artigo, focaremos especificamente nos conceitos de “afinidade” e “antiafinidade” que fornecem controle granular do agendamento. As afinidades definem regras que devem ou devem ser atendidas antes que um Pod possa ser alocado a um Node.
Como funciona a afinidade?
As afinidades são usadas para expressar restrições de agendamento de pods que podem corresponder às características dos nós candidatos e dos pods que já estão em execução nesses nós. É mais provável que um Pod que tenha uma “afinidade” com um determinado Node seja agendado para ele; por outro lado, uma “anti-afinidade” torna menos provável que seja agendado. O equilíbrio geral desses pesos é usado para determinar o posicionamento final de cada Pod.
As avaliações de afinidade podem produzir resultados difíceis ou suaves. Um resultado "difícil" significa que o nó devo têm as características definidas pela expressão de afinidade. Afinidades “soft” atuam como preferência, indicando ao escalonador que deve utilizar um Node com as características se houver. Um Node que não atende à condição ainda será selecionado, se necessário.
Tipos de Condição de Afinidade
Atualmente, existem dois tipos diferentes de afinidade que você pode definir:
- Afinidade do nó – Usado para restringir os nós que podem receber um pod combinando os rótulos desses nós. Node Affinity só pode ser usado para definir afinidades positivas que atraem Pods para o Node.
- Afinidade entre pods – Usado para restringir os Nodes que podem receber um Pod combinando rótulos dos pods existentes já em execução em cada um desses nós. A afinidade entre pods pode ser uma afinidade atrativa ou uma antiafinidade repelente.
No exemplo mais simples possível, um pod que inclui uma condição de afinidade de nó de label=value só será agendado para nós com um label=value rótulo. Um Pod com a mesma condição, mas definido como Inter-Pod Affinity, será agendado para um Node que já hospeda um Cápsula com um label=value rótulo.
Configurando afinidades de nós
Node Affinity tem dois subtipos distintos:
requiredDuringSchedulingIgnoredDuringExecution– Este é o matcher de afinidade “difícil” que requer o Node atende às restrições que você define.preferredDuringSchedulingIgnoredDuringExecution– Este é o matcher “soft” para expressar uma preferência que é ignorada quando não pode ser atendida.
O IgnoredDuringExecution parte desses nomes detalhados torna explícito que a afinidade é considerada apenas durante o agendamento de pods. Depois que um Pod chega a um Node, a afinidade não é reavaliada. As alterações no nó não causarão um despejo de pod devido a valores de afinidade alterados. Uma versão futura do Kubernetes pode adicionar suporte para esse comportamento por meio do reservado requiredDuringSchedulingRequiredDuringExecution frase.
As afinidades de nós são anexadas a Pods por meio de seus spec.affinity.nodeAffinity campo manifesto:
apiVersion: v1 kind: Pod metadata: name: demo-pod spec: containers: - name: demo-container # ... affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: hardware-class operator: In values: - a - b - c - matchExpressions: - key: internal operator: Exists
Esse manifesto cria uma regra de afinidade rígida que agenda o pod para um nó que atende aos seguintes critérios:
- Tem um
hardware-classetiqueta com qualquer uma,bouccomo o valor. - Tem um
internaletiqueta com qualquer valor.
Você pode anexar condições adicionais repetindo o matchExpressions cláusula. Os operadores suportados para comparações de valor são In, NotIn, Exists, DoesNotExist, Gt (maior que), e Lt (Menor que).
O matchExpression cláusulas agrupadas em um único nodeSelectorTerms cláusula são combinadas com um booleano AND. Todos eles precisam corresponder a um Pod para obter afinidade com um nó específico. Você pode usar vários nodeSelectorTerms cláusulas também; estes serão combinados como uma lógica OR Operação. Você pode facilmente montar critérios de programação complexos utilizando ambas as estruturas.
As preferências de agendamento “soft” são configuradas de maneira semelhante. Usar nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution em vez de ou assim como requiredDuringSchedulingIgnoredDuringExecution para configurá-los. Defina cada uma de suas restrições opcionais como um matchExpressions cláusula dentro de um preference campo:
apiVersion: v1 kind: Pod metadata: name: demo-pod spec: containers: - name: demo-container # ... affinity: nodeAffinity: preferredDuringSchedulingIgnoredDuringExecution: - weight: 1 preference: matchExpressions: - key: hardware-class operator: In values: - a - b - c
As regras baseadas em preferências têm um campo adicional chamado weight que aceita um inteiro de 1 a 100. Cada Node que corresponde a uma preferência tem seu peso de afinidade total incrementado pelo valor definido; o Node que terminar com o maior peso geral será alocado ao Pod.
Como definir afinidades entre pods
As afinidades entre pods funcionam de maneira muito semelhante às afinidades de nós, mas têm algumas diferenças importantes. Os modos “hard” e “soft” são indicados usando o mesmo requiredDuringSchedulingIgnoredDuringExecution e preferredDuringSchedulingIgnoredDuringExecution Campos. Estes devem ser aninhados sob o spec.affinity.podAffinity ou spec.affinity.podAntiAffinity campos dependendo se você deseja aumentar ou reduzir a afinidade do pod após uma correspondência bem-sucedida.
Aqui está um exemplo simples que demonstra afinidade e antiafinidade:
apiVersion: v1 kind: Pod metadata: name: demo-pod spec: containers: - name: demo-container # ... affinity: podAffinity: requiredDuringSchedulingIgnoredDuringExecution: - labelSelector: matchExpressions: - key: hardware-class operator: In values: - a - b - c topologyKey: topology.kubernetes.io/zone podAntiAffinity: preferredDuringSchedulingIgnoredDuringExecution: - weight: 1 podAffinityTerm: - labelSelector: matchExpressions: - key: app-component operator: In values: - background-worker topologyKey: topology.kubernetes.io/zone
O formato difere ligeiramente do Node Affinity. Cada matchExpressions restrição precisa ser aninhada em um labelSelector. Para partidas suaves, este, por sua vez, deve estar localizado dentro de um podAffinityTerm. As afinidades de pod também oferecem um conjunto reduzido de operadores de comparação: você pode usar In, NotIn, Exists e DoesNotExist.
As afinidades de pod precisam de um topologyKey campo. Isso é usado para limitar o conjunto geral de nós que são considerados elegíveis para agendamento, antes do matchExpressions são avaliados. As regras acima agendarão o Pod para um Node com o topology.kubernetes.io/zone rótulo e um Pod existente com o hardware-class rótulo definido para a, bou c. Nós que também possuem um Pod com o app-component=background-worker rótulo receberá uma afinidade reduzida.
As afinidades entre pods são um mecanismo poderoso para controlar a colocação de pods. No entanto, eles têm um impacto significativo no desempenho: o Kubernetes adverte contra o uso deles em clusters com mais de algumas centenas de nós. Cada nova solicitação de agendamento de pod precisa verificar todos os outros pods em todos os outros nós para avaliar a compatibilidade.
Outras restrições de agendamento
Embora tenhamos focado nas afinidades neste artigo, o Kubernetes também fornece outros mecanismos de restrição do agendador. Normalmente, essas são abordagens mais simples, mas menos automatizadas, que funcionam bem para clusters e implantações menores.
A restrição mais básica é a nodeSelector campo. Ele é definido nos pods como um conjunto de pares de valores-chave de rótulos que devem existir nos nós que hospedam o pod:
apiVersion: v1 kind: Pod metadata: name: demo spec: containers: - name: demo # ... nodeSelector: hardware-class: a internal: true
Este manifesto instrui o Kubernetes a agendar apenas o pod para nós com o hardware-class: a e internal: true rótulos.
Seleção de nós com o nodeSelector field é uma boa maneira de montar rapidamente a configuração estática com base em atributos de longa duração de seus Nodes. O sistema de afinidade é muito mais flexível quando você deseja expressar regras complexas e preferências opcionais.
Conclusão
Afinidades e antiafinidades são usadas para configurar restrições versáteis de agendamento de pods no Kubernetes. Em comparação com outras opções como nodeSelectoras afinidades são complexas, mas oferecem mais maneiras de identificar Nodes compatíveis.
As afinidades podem atuar como preferências suaves que sinalizam o ambiente “ideal” de um Pod para o Kubernetes, mesmo que não possa ser satisfeito imediatamente. O sistema também tem a capacidade exclusiva de filtrar nós com base em suas cargas de trabalho existentes para que você possa implementar regras de colocation de pods.
Um último ponto a ser observado é que a afinidade não é o fim do processo de agendamento. Um Pod com uma forte afinidade computada com um Node ainda pode acabar em outro lugar devido à entrada de taints do Node. Esse mecanismo permite gerenciar solicitações de agendamento da perspectiva de seus nós. As máculas repelem ativamente os Pods de entrada para outros Nodes, efetivamente o oposto da atração magnética das afinidades. Seletores de nós, afinidades, taints e tolerâncias são todos balanceados para determinar a localização final no cluster de cada novo Pod.
Fonte Adicione ao Google Notícias



