Como definir as tolerações de Kubernetes
O que são tolerações e contas em Kubernetes?
Toleração e mancha em Kubernetes são usados para garantir que as vagens sejam colocadas no nó correto. A tolerância é definida na especificação do POD, enquanto as contas são definidas na especificação do nó. Quando você aplica a tolerância em uma vagem, ele permite que o agendador agende as vagens em um nó específico. No entanto, as contas funcionam opostas à tolerância. Ele permite que o nó rejeite os pods a serem agendados. As vagens só podem ser agendadas no nó se tiverem tolerações aplicadas a eles com as manchas correspondentes.
Kubernetes trabalha com vagens, grupos, nós, eventos, etc. Em alguns casos, para gerenciar essas coisas, Kubernetes precisa de tolerações e contas. A tolerância é a implementação do processo de agendamento. As vagens precisam ser agendadas para que possam funcionar corretamente e podem ter recursos suficientes quando necessário para executar sua operação. As tolerações são aplicadas às vagens contra manchas para que não tenham nenhuma interrupção ou interrupção enquanto trabalham.
As contas em Kubernetes permitem que uma vagem rejeite o agendamento de uma vagem. É aplicado a um nó usando a especificação do nó "NodeSpec". O agendador não consegue colocar uma vagem em um nó que tenha uma mancha. No entanto, se você precisar agendar as vagens em um nó onde uma mancha já está aplicada, você precisa declarar a tolerância contra ele.
A tolerância em Kubernetes permite que uma vagem seja agendada em um nó onde uma mancha já é aplicada. A tolerância em uma vagem é aplicada usando a especificação de pod "Podspec". Quando você aplica a tolerância em uma vagem com uma mancha correspondente, o Agendador pode agendar facilmente os pods em um nó específico.
Agora, vamos apresentar um cenário para ajudá -lo a entender como você pode implementar a tolerância em uma vagem em Kubernetes. Antes de prosseguir para a seção de implementação, verifique se você tem todos os requisitos de pré -requisito.
Pré -requisito:
A seguir, são apresentadas as coisas que você precisa para implementar a tolerância em um nó em Kubernetes:
- Ubuntu 20.04 ou qualquer outra versão mais recente de qualquer sistema Linux
- Minikube (versão mais recente)
- Máquina virtual instalada em seu sistema Linux/Unix
- Ferramenta de linha de comando kubectl
Supondo que seu sistema atenda a todas as necessidades dos pré -requisitos, vamos começar a definir a tolerância de Kubernetes.
Etapa 1: Inicie o terminal Minikube
A primeira coisa que você precisa fazer é iniciar o terminal Minikube, para que você possa usar os comandos Kubectl para a implementação da tolerância de Kubernetes em um nó. Para iniciar o minikube, o seguinte comando é usado:
> Minikube Start
Após a execução deste comando, você obtém a seguinte saída em seu terminal:
Etapa 2: Obtenha a lista de nós ativos
Agora que começamos o Minikube, nosso sistema está pronto para definir a tolerância em pods em Kubernetes. Antes de definirmos a tolerância nas vagens, vamos verificar quantos nós e que tipo de nós já temos. Para fazer isso, usamos o seguinte comando subsequente:
> kubectl get nós -o = colunas personalizadas = nodename:.Metadados.Nome, Taintkey:.espec.Taints [*].chave, TaintValue:.espec.Taints [*].Valor, Tainteffect:.espec.Taints [*].efeito
Esta instrução lista todos os nós que são contaminados pela instalação padrão do Kubernetes. Vamos primeiro ver a saída deste comando. Em seguida, discutimos a lista de nós:
Como não há nós que sejam criados e contaminados pela instalação padrão de Kubernetes e também não criamos especificamente nenhum nó, o resultado é . Da saída anterior, podemos ver que não há nó. Portanto, primeiro criamos o nó e depois definimos a tolerância. Para definir a tolerância em uma vagem em Kubernetes, primeiro precisamos implantar um aplicativo em um cluster. As próximas etapas demonstram como implantar um aplicativo em um cluster.
Etapa 3: Crie um espaço para nome
Primeiro, criamos um espaço para nome para implantar um aplicativo em um cluster. Aqui, criamos um aplicativo com o valor "front -end" com a ajuda do seguinte comando:
> Kubectl Crie Frontend ns
Este comando cria o espaço para nome com o valor "front -end". Veja a seguinte saída:
Etapa 4: Implante o Nginx POD no espaço para nome
Agora, implante o pod nginx no espaço de nome que acabamos de criar. Usamos o seguinte comando para implantar o nginx:
> kubectl run nginx -image = nginx -Namespace Frontend
Isso implanta um aplicativo em um cluster sem configuração de tolerância na especificação da implantação do aplicativo. Usando o comando kubectl, implantamos o Nginx POD no frontend do espaço para nome:
Etapa 5: Obtenha a lista de pods
Agora, vamos verificar os pods criados para ver seus status. O comando dado lista todas as vagens e seus status também:
> KUBECTL GET PODS -N FRONTEND
Como só criamos o nginx, este comando deve listar esse pod com seu status. Veja a seguinte saída:
Etapa 6: Analise os eventos de Kubernetes
Agora, vamos analisar os eventos em Kubernetes para que possamos definir a tolerância nas vagens. Usamos o seguinte comando Kubectl para obter a lista de eventos em Kubernetes:
> KUBECTL Get Events -N Frontend
Isso lista todos os eventos associados ao valor front-end, juntamente com suas propriedades como tipo, razão, objeto e mensagem. Veja a lista fornecida na seguinte saída:
Como você pode ver na saída anterior, o Nginx POD está agendado com a tolerância específica. A propriedade "Mensagem" mostra a lista de ações que são executadas ao longo do processo.
Etapa 7: verifique o status dos pods
A etapa final é verificar novamente o status da vagem que criamos anteriormente para garantir que ele seja agendado com sucesso em um nó específico e correto. Para fazer isso, usamos o seguinte comando kubectl:
> KUBECTL GET PODS -N FRONTEND
Como pode ser visto na saída anterior, o pod agora pode ser executado no nó contaminado, já que a tolerância está contra ele.
Conclusão
Neste guia, exploramos sobre as manchas e tolerância. Aprendemos sobre o trabalho básico de contas e tolerância. Então, implementamos a tolerância em um pod. Com a ajuda de um exemplo simples, aprendemos a definir a tolerância em um nó em Kubernetes.