Como controlar a programação com taints de nó

Nesta página, mostramos uma visão geral dos taints de nó no Google Kubernetes Engine. Quando você programa a implantação de cargas de trabalho no cluster, taints de nó o ajudam a controlar quais nós elas podem executar.

Visão geral

Quando você envia uma carga de trabalho para executar em um cluster, o programador determina onde colocar os pods associados à carga de trabalho. O programador é livre para colocar um pod em qualquer node que satisfaça os requisitos de recursos personalizados, de CPU e de memória do pod.

Se o cluster executa várias cargas de trabalho, convém exercer um controle sobre quais cargas de trabalho podem ser executadas em um pool de nós em particular.

Com um taint de node, você marca um node para que o programador evite ou impeça o uso dele em determinados pods. Com o recurso adicional tolerâncias, você designa pods que podem ser usados em nodes com taint.

Os taints de node são pares de chave-valor associados a um efeito. Veja abaixo os efeitos disponíveis:

  • NoSchedule: pods que não toleram esse taint não são programados no nó.
  • PreferNoSchedule: o Kubernetes evita a programação de pods que não toleram esse taint no nó.
  • NoExecute: o pod é removido do nó caso esteja em execução nele, e não é programado no nó caso não esteja em execução nele.

Antes de começar

Prepare-se para a tarefa tomando as seguintes medidas:

  • Verifique se você ativou a API Google Kubernetes Engine.
  • Ativar a API Google Kubernetes Engine
  • Verifique se o SDK do Cloud está instalado.
  • Defina o código do projeto padrão:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona de computação padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região de computação padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize a gcloud para a versão mais recente:
    gcloud components update

Como criar um cluster com taints de nó

Quando você cria um cluster, pode atribuir manchas de node a ele. Isso atribui as manchas a todos os nodes criados com o cluster.

gcloud

Para criar um cluster com taints de node, execute o comando a seguir:

gcloud container clusters create [CLUSTER_NAME] --node-taints [KEY]=[VALUE]:[EFFECT]

em que:

  • [CLUSTER_NAME] é o nome do cluster a ser criado;
  • [EFFECT] é PreferNoSchedule, NoSchedule ou NoExecute;
  • [KEY] e [VALUE] formam um par de chave-valor associado a [EFFECT].

Por exemplo, este comando aplica um taint com chave dedicated, valor experimental e efeito PreferNoSchedule:

gcloud container clusters create example-cluster --node-taints dedicated=experimental:PreferNoSchedule

Console

Para criar um cluster com taints de nó, execute as seguintes etapas:

  1. Acesse o menu do Google Kubernetes Engine no console do GCP.

    Acessar o menu do Google Kubernetes Engine

  2. Clique em Criar cluster.

  3. Configure o cluster como quiser. Em seguida, clique na opção Edição avançada referente ao pool de nós que você quer modificar.

  4. Na seção Nós, clique em Adicionar taint.

  5. Em Efeito, selecione o efeito pretendido.

  6. Preencha Chave e Valor com o par de chave-valor pretendido.

  7. Adicione mais taints de nó, se quiser.

  8. Clique em Salvar para fechar a sobreposição Edição avançada.

  9. Clique em Criar.

API

Quando você usar a API para criar um cluster, inclua o campo nodeTaints em nodeConfig. Veja um exemplo:

POST https://container.googleapis.com/v1/projects/[PROJECT_ID]/zones/[ZONE]/clusters

{
  'cluster': {
    'name': 'example-cluster',
    'nodeConfig': {
      'nodeTaints': [
        {
          'key': 'special',
          'Value': 'gpu',
          'effect': 'PreferNoSchedule'
        }
      ]
      ...
    }
    ...
  }
}

Como criar um pool de nós com manchas de node

Quando você aplica um taint a um nó, somente pods que toleram o taint podem ser executados no nó. Em um cluster do GKE, você pode aplicar um taint a um pool de nós, o que aplica o taint a todos os nós no pool.

Para criar um pool de nós com taints de nós, você pode usar a ferramenta de linha de comando gcloud ou a API GKE.

gcloud

Para criar um pool de nodes com taints de node, execute o comando a seguir:

gcloud container node-pools create [POOL_NAME] --cluster [CLUSTER_NAME] \
--node-taints [KEY]=[VALUE]:[EFFECT]

em que:

  • [POOL_NAME] é o nome do pool de nós a ser criado;
  • [CLUSTER_NAME] é o nome do cluster em que o pool de nós será criado;
  • [EFFECT] é PreferNoSchedule, NoSchedule ou NoExecute;
  • [KEY] e [VALUE] formam um par de chave-valor associado a [EFFECT].

Por exemplo, este comando aplica um taint com chave dedicated, valor experimental e efeito NoSchedule:

gcloud container node-pools create example-pool --cluster example-cluster \
--node-taints dedicated=experimental:NoSchedule

Este comando aplica um taint com chave special, valor gpu e efeito NoExecute:

gcloud container node-pools create example-pool-2 --cluster example-cluster \
--node-taints special=gpu:NoExecute

Console

Para criar um pool de nós com taints de nó, execute as seguintes etapas:

  1. Acesse o menu do Google Kubernetes Engine no console do GCP.

    Acessar o menu do Google Kubernetes Engine

  2. Clique no botão de edição do cluster, que tem a forma de um lápis.

  3. Em Pools de nós, clique em Adicionar pool de nós.

  4. Na seção Nós, clique em Adicionar taint.

  5. Em Efeito, selecione o efeito pretendido.

  6. Preencha Chave e Valor com o par de chave-valor pretendido.

  7. Adicione mais taints de nó, se quiser.

  8. Clique em Salvar para sair da sobreposição de modificação do pool de nós.

  9. Clique em Criar.

API

Quando você usar a API para criar um pool de nós, inclua o campo nodeTaints em nodeConfig. Veja um exemplo:

POST https://container.googleapis.com/v1/projects/[PROJECT_ID]/zones/[ZONE]/clusters/[CLUSTER_ID]/nodePools

{
  'nodePool': {
    'name': 'example-pool',
    'nodeConfig': {
      'nodeTaints': [
        {
          'key': 'dedicated',
          'Value': 'experimental',
          'effect': 'NoSchedule'
        }
      ]
      ...
    }
    ...
  }
}

Como configurar pods para que tolerem uma mancha

Você pode configurar pods para que tolerem uma mancha, incluindo o campo tolerations na especificação deles. Veja a seguir uma parte de uma especificação de pod.

Este pod pode ser programado em um node com a mancha dedicated=experimental:NoSchedule:

tolerations:
- key: dedicated
  operator: Equal
  value: experimental
  effect: NoSchedule

Como adicionar uma mancha a um node existente

Adicione taints a um nó atual usando o comando kubectl taint:

kubectl taint nodes [NODE_NAME] [KEY]=[VALUE]:[EFFECT]

Por exemplo:

kubectl taint nodes node1 key=value:NoSchedule

Também é possível fazer isso com um marcador específico:

kubectl taint node -l myLabel=X dedicated=foo:PreferNoSchedule

Para saber mais, consulte Taints e tolerâncias na documentação do Kubernetes.

Como inspecionar os taints de um node

Para ver os taints de um node, use a ferramenta de linha de comando kubectl.

Primeiro, para receber uma lista de todos os nodes no cluster, execute o comando a seguir:

kubectl get nodes

Para inspecionar um node:

kubectl describe node [NODE_NAME]

Na descrição do node retornado, procure o campo Taints:

Taints: [KEY]=[VALUE]:[EFFECT]

Como remover uma mancha de um node

Você pode usar kubectl taint para remover manchas. Você pode remover manchas por chave, chave-valor ou chave-efeito.

Por exemplo, o comando a seguir remove do node foo todas as manchas com a chave dedicated:

kubectl taint nodes foo dedicated-

Vantagens de usar manchas de node

Usar manchas de node em vez de configurar manchas manualmente usando kubectl tem várias vantagens:

  • As manchas são preservadas quando um node é reiniciado ou substituído.
  • As manchas são criadas automaticamente quando um node é adicionado a um pool ou cluster.
  • As manchas são criadas automaticamente durante o escalonamento automático do cluster.

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine