Scheduler

No Kubernetes, o scheduler é um componente essencial para atribuir tarefas aos nós disponíveis dentro de um cluster. Ele desempenha um papel fundamental no gerenciamento da distribuição de carga e na utilização eficiente dos recursos.

Funcionalidade do Scheduler

• Tomada de decisão: O scheduler toma decisões com base em vários fatores, como requisitos de recursos, restrições de afinidade, limitações de hardware, políticas de segurança e preferências de balanceamento de carga.
• Encontrar nós adequados: O objetivo do scheduler é encontrar um nó adequado para executar cada tarefa, levando em consideração os recursos necessários e as políticas de agendamento.

Processo de Agendamento

• Consulta do estado do cluster: O scheduler consulta o estado atual do cluster para obter informações sobre os recursos disponíveis e as restrições definidas.
• Atribuição da tarefa: Com base nas informações obtidas, o scheduler atribui a tarefa ao nó mais apropriado, levando em consideração requisitos, restrições e preferências.

Otimização e Personalização

• Otimização da distribuição de carga: O scheduler pode equilibrar a carga de trabalho entre os nós existentes, garantindo a utilização eficiente dos recursos do cluster.
• Personalização e extensibilidade: O scheduler pode ser personalizado de acordo com as necessidades do ambiente, permitindo a definição de políticas de agendamento personalizadas, implementação de algoritmos de balanceamento de carga específicos ou utilização de recursos adicionais para a tomada de decisões.

Scheduling Manual

Para criar um pod em um nó especifico é necessário informar ao scheduler. Vamos começar com um simples arquivo de definição de pods. Cada pod tem um campo chamado nodeName que, por padrão, não está definido.

kubectl explain pods.spec.nodeName

Normalmente não se especifica este campo quando se cria o arquivo de manifesto da pod. O Kubernetes adiciona-o automaticamente. Para atribuir manualmente os pods aos nós sem um scheduler, a maneira mais fácil é simplesmente definir o campo nodeName em seu arquivo de especificação do pod enquanto cria o pod.

apiVersion: v1
kind: Pod
metadata:
  name: mypod-app
  labels:
    app: mypod
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
      - containerPort: 80
  nodeName: node01 

Labels e Selectors

As labels e selectors são métodos padrão para agrupar as coisas. Os labels são propriedades anexadas a cada item, portanto você adiciona propriedades a cada item para sua classe e tipo. Os selectors ajudam a filtrar estes itens.

Criamos muitos tipos diferentes de objetos em Kubernetes, pods, services, replicaset, deployments, etc. Para o Kubernetes, todos estes são objetos diferentes. Com o tempo, você pode acabar tendo centenas ou milhares desses objetos em seu cluster. Então você precisará de uma maneira de filtrar e visualizar diferentes objetos por diferentes categorias, tais como agrupar objetos por seu tipo ou visualizar objetos por aplicação ou por sua funcionalidade. Seja o que for, você pode agrupar e selecionar objetos usando labels e selectors.

Para cada objeto, anexe labels conforme suas necessidades, como app, function e etc. Depois, ao selecionar, especifique uma condição para filtrar objetos específicos. Por exemplo, app=myapp.

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  labels:
    app: myapp 
    function: font-end 
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
      - containerPort: 80

Em um arquivo de definição de pods, em metadados, criar uma seção chamada labels. e acrescente as labels em um formato de chave/valor conforme exemplo abaixo. Você pode adicionar quantas labels quiser. Uma vez criado o pod, para selecionar o pod com as labels, use o comando kubectl get pods junto com a opção selector e especifique a condição como app=myapp.

kubectl get pods --selector app=myapp

Praticando nodeName, Labels e Selectors

Exemplos práticos de como você pode usar os recursos de nodename, labels e selectors no Kubernetes:

Atividade 1: Usando nodename para implantar um pod em um nó específico:

Passo 1.1: Você pode usar o campo spec.nodeName no manifesto do pod para definir em qual nó o pod deve ser implantado. Por exemplo:

apiVersion: v1
kind: Pod
metadata:
  name: meu-pod
spec:
  nodeName: nome-do-no
  containers:
    - name: meu-container
      image: nginx

Isso garante que o pod será implantado apenas no nó com o nome especificado.

Atividade 2: Usando labels e selectors para implantar um conjunto de pods:

Passo 2.1. Você pode atribuir labels aos seus pods e, em seguida, usar os selectors para implantar conjuntos de pods com base nessas labels. Por exemplo:

apiVersion: v1
kind: Pod
metadata:
  name: meu-pod-1
  labels:
    app: minha-aplicacao
spec:
  containers:
    - name: meu-container
      image: nginx
---
apiVersion: v1
kind: Pod
metadata:
  name: meu-pod-2
  labels:
    app: minha-aplicacao
spec:
  containers:
    - name: meu-container
      image: nginx

Passo 2.2. Verifique se os dois pods foram criados, depois escolha qualquer um e remova-o.

kubectl delete pod meu-pod-1

Passo 2.3. Confirme se o pod foi removido e recrie utilizando aplicando o arquivo yaml criado na atividade 2 passo 1.

kubectl get pods

Atividade 3: Criando um Replication controller para gerenciar os pods.

Passo 3.1. Agora, você pode usar um seletor para implantar todos os pods com a label app: minha-aplicacao. Por exemplo:

apiVersion: v1
kind: ReplicationController
metadata:
  name: meu-rc
spec:
  replicas: 2
  selector:
    matchLabels:
      app: minha-aplicacao
  template:
    metadata:
      labels:
        app: minha-aplicacao
    spec:
      containers:
        - name: meu-container
          image: nginx

Passo 3.2. Verifique se os dois pods continuam em execução, depois escolha qualquer um e remova-o.

kubectl delete pod meu-pod-1

Dessa forma, o Replication Controller irá garantir que sempre haja dois pods com a label app: minha-aplicacao em execução.

Esses são apenas alguns exemplos de como você pode usar nodename, labels e selectors no Kubernetes. Esses recursos são poderosos para controlar a implantação e a seleção de recursos dentro do seu cluster Kubernetes.