Kubernetes LimitRange: Gerenciamento de Recursos e Otimização do Cluster

Introdução

Neste laboratório, você aprenderá sobre o Kubernetes LimitRange, que é usado para definir limites no consumo de recursos em pods do Kubernetes. LimitRange é um recurso do Kubernetes que ajuda a gerenciar os recursos alocados aos pods e a evitar problemas de contenção de recursos.

Você passará por uma série de instruções passo a passo para entender os diferentes aspectos do LimitRange, começando por exemplos simples e avançando gradualmente para cenários mais complexos. Cada etapa incluirá exemplos de código na forma de manifestos YAML que você pode aplicar ao seu cluster Kubernetes para ver os efeitos do LimitRange em ação.

Iniciar o Cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

Navegue para o seu diretório de trabalho:

Abra o terminal e navegue até a pasta do projeto padrão:
```
cd /home/labex/project
```
Inicie o Minikube:

Inicie o Minikube para inicializar um cluster Kubernetes:
```
minikube start
```
- Este comando configura um cluster Kubernetes de nó único em sua máquina local.
- O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.
Verifique se o Minikube está em execução:

Verifique o status do cluster Minikube:
```
minikube status
```
- Procure por componentes como kubelet e apiserver listados como Running (Em execução).
- Se o cluster não estiver em execução, execute minikube start novamente.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Criando um LimitRange Simples

Nesta etapa, você criará um LimitRange simples que define limites nos recursos de CPU e memória para pods em um namespace. Veja como você pode fazer isso:

Crie um novo arquivo YAML chamado limitrange.yaml com o seguinte conteúdo:

cd ~/project
touch limitrange.yaml

apiVersion: v1
kind: LimitRange
metadata:
  name: example-limitrange
spec:
  limits:
    - type: Container
      max:
        cpu: "1"
        memory: "1Gi"
      min:
        cpu: "100m"
        memory: "100Mi"
      default:
        cpu: "500m"
        memory: "500Mi"

Este LimitRange define os seguintes limites:

CPU máxima: 1 core
Memória máxima: 1 GiB
CPU mínima: 100 milli-cores (100m)
Memória mínima: 100 MiB
CPU padrão: 500 milli-cores (500m)
Memória padrão: 500 MiB

Aplique o arquivo limitrange.yaml ao seu cluster Kubernetes usando o comando kubectl apply:
```
kubectl apply -f limitrange.yaml
```
Verifique se o LimitRange foi criado com sucesso executando o seguinte comando:
```
kubectl describe limitrange example-limitrange
```
Você deve ver o LimitRange example-limitrange listado com os limites que você especificou na seção spec.

Aplicando LimitRange aos Pods

Nesta etapa, você criará um pod que está sujeito ao LimitRange que você criou em "Criando um LimitRange Simples". Veja como você pode fazer isso:

Crie um novo arquivo YAML chamado pod.yaml com o seguinte conteúdo:
```
cd ~/project
touch pod.yaml
```
```
apiVersion: v1
kind: Pod
metadata:
  name: example-pod
spec:
  containers:
    - name: nginx
      image: nginx
```
Esta definição de pod cria um pod simples com um único container executando a imagem Nginx.
Aplique o arquivo pod.yaml ao seu cluster Kubernetes usando o comando kubectl apply:
```
kubectl apply -f pod.yaml
```
Verifique se o pod foi criado com sucesso executando o seguinte comando:
```
kubectl get pods example-pod
```
Você deve ver o pod example-pod listado com o status Running (Em execução).
Verifique os limites de recursos aplicados ao pod executando o seguinte comando:
```
kubectl describe pod example-pod
```
Você deve ver os limites de CPU e memória para o pod conforme definido.

Testando a Aplicação do LimitRange

Nesta etapa, você testará a aplicação do LimitRange tentando criar um pod que excede os limites de recursos definidos no LimitRange. Veja como você pode fazer isso:

Crie um novo arquivo YAML chamado pod-exceeding-limits.yaml com o seguinte conteúdo:

cd ~/project
touch pod-exceeding-limits.yaml

apiVersion: v1
kind: Pod
metadata:
  name: example-pod-exceeding-limits
spec:
  containers:
    - name: nginx
      image: nginx
      resources:
        limits:
          cpu: "2"
          memory: "2Gi"

Esta definição de pod cria um pod com um container que solicita recursos que excedem os limites definidos no LimitRange (CPU: 2 cores, memória: 2 GiB).

Aplique o arquivo pod-exceeding-limits.yaml ao seu cluster Kubernetes usando o comando kubectl apply:
```
kubectl apply -f pod-exceeding-limits.yaml
```
Você pode ver que a operação para criar o Pod é rejeitada. A mensagem de erro é Error from server (Forbidden): error when creating "pod-exceeding-limits. yaml": pod "example-pod-exceeding-limits " Forbidden: [Maximum cpu usage per container is 1, but limited to 2, maximum memory usage per container is 1Gi, but limited to 2Gi].

Atualizando o LimitRange

Nesta etapa, você atualizará o LimitRange criado em "Criando um LimitRange Simples" para modificar os limites de recursos. Veja como você pode fazer isso:

Modifique o arquivo limitrange.yaml para atualizar os limites de recursos de acordo com seus requisitos. Por exemplo:
```
apiVersion: v1
kind: LimitRange
metadata:
  name: example-limitrange
spec:
  limits:
    - type: Container
      max:
        cpu: "2"
        memory: "2Gi"
      min:
        cpu: "200m"
        memory: "200Mi"
      default:
        cpu: "1"
        memory: "1Gi"
```
Este LimitRange atualizado define os seguintes limites:
- CPU máximo: 2 cores
- Memória máxima: 2 GiB
- CPU mínima: 200 milli-cores (200m)
- Memória mínima: 200 MiB
- CPU padrão: 1 core
- Memória padrão: 1 GiB
Aplique o arquivo limitrange.yaml atualizado ao seu cluster Kubernetes usando o comando kubectl apply:
```
kubectl apply -f limitrange.yaml
```
Verifique se o LimitRange foi atualizado com sucesso executando o seguinte comando:
```
kubectl describe limitranges example-limitrange
```
Você deve ver os limites de recursos atualizados refletidos na saída.

Resumo

Neste laboratório, você aprendeu como usar o LimitRange do Kubernetes para definir limites no consumo de recursos em pods. Você começou criando um LimitRange simples, aplicou-o a um pod, testou sua aplicação e, em seguida, atualizou o LimitRange para modificar os limites de recursos. O LimitRange é uma ferramenta poderosa para gerenciar recursos no Kubernetes e garantir o uso eficiente de recursos em seu cluster.

Gerenciamento de Recursos Kubernetes LimitRange