Gerenciamento de Resource Quota no Kubernetes: Guia Completo

Introdução

Neste laboratório, você aprenderá como usar o Kubernetes ResourceQuota para definir limites no consumo de recursos em um cluster Kubernetes. ResourceQuota permite controlar e gerenciar a alocação de recursos como CPU e memória para namespaces em um cluster Kubernetes. Você começará com exemplos simples e progredirá gradualmente para cenários mais complexos. Cada etapa fornecerá exemplos de código e instruções sobre como aplicá-los ao seu cluster Kubernetes.

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.
- Se o cluster não estiver em execução, execute novamente minikube start.

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

Criando um ResourceQuota

Nesta etapa, você criará um ResourceQuota simples que limita a quantidade de CPU e memória que pode ser usada em um namespace. Veja como você pode fazer isso:

Crie um arquivo chamado resourcequota.yaml com o seguinte conteúdo:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: example-resourcequota
spec:
  hard:
    cpu: "1"
    memory: "1Gi"

Este ResourceQuota define os seguintes limites rígidos (hard limits):

CPU: 1 core
Memória: 1 GiB

Aplique o arquivo resourcequota.yaml ao seu cluster Kubernetes usando o comando kubectl apply:

kubectl apply -f resourcequota.yaml

Verifique se o ResourceQuota foi criado com sucesso executando o seguinte comando:

kubectl describe resourcequota example-resourcequota

Você deve ver os detalhes do ResourceQuota na saída.

Aplicando ResourceQuota a um Namespace

Nesta etapa, você aplicará o ResourceQuota criado em Step:Creating a ResourceQuota a um namespace. Veja como você pode fazer isso:

Crie um arquivo chamado namespace.yaml com o seguinte conteúdo:

apiVersion: v1
kind: Namespace
metadata:
  name: example-namespace

Esta definição de namespace cria um namespace chamado example-namespace.

Aplique o arquivo namespace.yaml ao seu cluster Kubernetes usando o comando kubectl apply:

kubectl apply -f namespace.yaml

Aplique o ResourceQuota ao namespace example-namespace usando o comando kubectl apply:

kubectl apply -f resourcequota.yaml -n example-namespace

Verifique se o ResourceQuota foi aplicado ao namespace executando o seguinte comando:

kubectl describe namespace example-namespace

Você deve ver os detalhes do ResourceQuota aplicado ao namespace na saída.

Testando a Aplicação do ResourceQuota

Nesta etapa, você criará um pod que excede os limites de recursos definidos no ResourceQuota e verificará se o ResourceQuota aplica esses limites. Veja como você pode fazer isso:

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

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 ResourceQuota criado em Step:Creating a ResourceQuota (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": pods "example-pod-exceeding-limits" is forbidden: exceeded quota: example-resourcequota, requested: cpu=2,memory=2Gi, used: cpu=0,memory=0, limited: cpu=1,memory=1Gi.

Modificando o ResourceQuota

Nesta etapa, você aprenderá como modificar um ResourceQuota existente para atualizar os limites de recursos. Veja como você pode fazer isso:

Edite o arquivo resourcequota.yaml para atualizar os limites de CPU e memória para valores mais altos:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: example-resourcequota
spec:
  hard:
    cpu: "2"
    memory: "2Gi"

Isso atualiza o ResourceQuota para permitir limites mais altos de CPU e memória (2 cores e 2 GiB, respectivamente).

Aplique o arquivo resourcequota.yaml atualizado ao seu cluster Kubernetes usando o comando kubectl apply:

kubectl apply -f resourcequota.yaml

Verifique se o ResourceQuota foi atualizado executando o seguinte comando:

kubectl describe resourcequotas example-resourcequota

Você deve ver os limites de CPU e memória atualizados na saída.

Resumo

Neste laboratório, você aprendeu como usar o ResourceQuota do Kubernetes para definir limites no consumo de recursos em um cluster Kubernetes. Você começou criando um ResourceQuota simples, aplicando-o a um namespace e testando sua aplicação criando um pod que excede os limites de recursos. Você também aprendeu como modificar um ResourceQuota existente para atualizar os limites de recursos. O ResourceQuota é uma ferramenta poderosa para gerenciar recursos em um cluster Kubernetes e garantir que as aplicações não consumam recursos excessivos.