Pular para o conteúdo

Kubernetes Resource Calculator · Kubernetes

Totalize a CPU e a memória do Kubernetes de relance.

Transforme requests e limits de CPU em millicores como 250m e memória em Mi / Gi em valores normalizados e totais considerando as réplicas — grátis, online, sem necessidade de cadastro.

Roda no seu navegador CPU e memória Sem cadastro Atualizado em 19 de jul. de 2026

Playground da Kubernetes Resource Calculator

CPU takes cores or millicores (500m, 1, 2.5). Memory takes binary (256Mi, 4Gi) or decimal (1G) suffixes, or bytes. Leave a field blank to skip it.

Result

Enter a CPU or memory value — or pick an example — to see a per-pod and total-across-replicas breakdown here.

O problema

Um sufixo errado, um node pool acima do orçamento.

As quantidades de recursos do Kubernetes misturam dois sistemas numéricos — núcleos fracionários medidos em millicores, e memória medida em mebibytes binários que parecem quase megabytes decimais. Multiplique de cabeça uma request por contêiner por um número de réplicas e o modo de falha é silencioso: um node pool dimensionado pequeno demais, um Pod que nunca é agendado, ou um limit fixado acidentalmente abaixo de sua request que o API server rejeita.

Esta calculadora de recursos do Kubernetes gratuita transforma essas quantidades nos dados concretos de que você realmente precisa — CPU normalizada em millicores, memória em bytes exatos, e o total de CPU e memória em pods e réplicas que uma carga de trabalho reserva e limita — para que você possa conferir os números antes que eles cheguem a um manifesto. Inteiramente no navegador, sem nada para instalar e sem que nenhum dado saia jamais do seu dispositivo.

Vai codificar os valores em um Secret na sequência? Recorra ao Base64 Encoder / Decoder.

O processo

Como funciona.

Quatro passos determinísticos rodam a cada tecla pressionada — tudo dentro da aba do seu navegador, com aritmética inteira exata.

  1. Parseia as quantidades.

    Cada request e limit é lido como uma quantidade do Kubernetes — um número mais um sufixo de unidade opcional como m, Mi ou Gi.

  2. Normaliza as unidades.

    A CPU é convertida para millicores inteiros e a memória para bytes exatos, de modo que os valores binários (Mi/Gi) e decimais (M/G) se comparem corretamente.

  3. Multiplica pelas réplicas.

    As requests e os limits por contêiner são multiplicados pelo número de réplicas para dar o total de CPU e memória que a carga de trabalho reserva e limita.

  4. Sinaliza os conflitos.

    Qualquer linha cujo limit normalizado seja menor que sua request é sinalizada, já que o Kubernetes rejeita um limit abaixo da request garantida.

Referência de unidades

O que cada sufixo significa.

A CPU do Kubernetes usa millicores; a memória usa duas famílias de sufixo — a binária Ki/Mi/Gi e a decimal K/M/G — que são próximas, mas nunca iguais.

Sufixos de CPU e memória

A CPU se normaliza para millicores (1000m = um núcleo); a memória se normaliza para bytes, onde Mi/Gi são 1024^n e M/G são 1000^n.

resource-suffixes
cpu suffix     meaning              example       millicores
(none)         whole cores          2             2000m
m              millicores           250m          250m
0.x            fractional cores     0.5           500m

memory suffix  meaning              example       bytes
Ki             1024^1  (binary)     512Ki         524,288
Mi             1024^2  (binary)     256Mi         268,435,456
Gi             1024^3  (binary)     2Gi           2,147,483,648
K              1000^1  (decimal)    512K          512,000
M              1000^2  (decimal)    256M          256,000,000
G              1000^3  (decimal)    2G            2,000,000,000

note  Mi/Gi are 1024^n (mebi/gibi); M/G are 1000^n (mega/giga).
      1 Gi = 1,073,741,824 bytes  ≈  1.074 GB

Totais considerando as réplicas

Cada request e limit por contêiner é multiplicado pelo número de réplicas, de modo que você pode dimensionar um node pool conforme as requests e vigiar o teto conforme os limits.

totals
container  requests          limits            replicas
api        cpu 250m mem 256Mi  cpu 500m mem 512Mi   3

totals
  cpu     requests 750m       limits 1500m  (1.5 cores)
  memory  requests 768Mi      limits 1536Mi (1.5 Gi)

Próximo passo

Já dimensionou? Codifique os valores em um Secret.

Quando as requests e os limits estiverem corretos, a configuração que os acompanha — tokens, strings de conexão, certificados — costuma ir para um Kubernetes Secret, cujos valores em data precisam estar codificados em Base64. O Base64 Encoder / Decoder cuida disso no navegador, ou explore o diretório completo de ferramentas para o restante do kit.

secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: api
type: Opaque
data:
  # values are base64-encoded
  token: c3VwZXItc2VjcmV0

FAQ

Suas perguntas, respondidas.

Toque em uma pergunta para expandir a resposta.

Um millicore (o sufixo m, como em 250m) é um milésimo de um núcleo de CPU, então 1000m equivale a uma vCPU / hyperthread. O Kubernetes mede a CPU nessas unidades fracionárias porque um Pod raramente precisa de um núcleo inteiro — 250m significa um quarto de um núcleo de fatia garantida. Um número simples como 0.5 é o mesmo que 500m; a calculadora normaliza tudo para millicores para que as requests e os totais batam.

Mi é um mebibyte — 1024 × 1024 = 1.048.576 bytes — enquanto MB normalmente significa um megabyte de 1.000.000 de bytes. Os sufixos de memória do Kubernetes Ki / Mi / Gi são binários (potências de 1024); os sufixos sem essa partícula K / M / G são decimais (potências de 1000). Eles são próximos, mas não iguais: 1 Gi é cerca de 1,074 GB. Misturá-los provoca silenciosamente um provisionamento insuficiente, então a calculadora mantém as duas famílias separadas e converte ambas para bytes exatos.

Uma request é o que o scheduler reserva para um contêiner — ela garante aquela quantidade de CPU e memória e é o que o bin-packing usa para alocar o Pod em um nó. Um limit é o teto absoluto: a CPU acima do limit sofre throttling, e a memória acima do limit faz o contêiner receber um OOM-kill. As requests guiam o planejamento de capacidade; os limits limitam o raio de impacto. A calculadora soma os dois para que você possa dimensionar um node pool conforme as requests e vigiar o teto conforme os limits.

É inválido — o API server do Kubernetes rejeita um contêiner cujo limit seja menor que sua request, porque você não pode limitar um recurso abaixo da quantidade que já garantiu. A calculadora sinaliza qualquer linha em que o limit normalizado fique abaixo da request normalizada, para que você detecte o erro aqui em vez de em um apply que falha ou na rejeição de um admission webhook.

Não. Cada quantidade é parseada, normalizada e totalizada 100% no lado do cliente na sua aba — não há servidor, não há conta e não há registros. Você pode colar com segurança blocos de recursos de manifestos internos; nada é enviado.

A request e o limit totais de um pod são a soma dos valores individuais de todos os seus contêineres. Multiplique esse total por pod pelo número de réplicas para obter o que o deployment inteiro reserva. Por exemplo, 3 réplicas com 250m de CPU e 256Mi de memória cada uma somam 750m de CPU e 768Mi. Informe os valores por contêiner e o número de réplicas na calculadora e ela calcula os totais da carga de trabalho na hora.

Mi (mebibytes) e Gi (gibibytes) são unidades binárias em que 1024Mi equivale a 1Gi. Divida Mi por 1024 para obter Gi, e multiplique Gi por 1024 para obter Mi. Um Gi equivale a 1.073.741.824 bytes, que é ligeiramente maior que 1G (1.000.000.000 de bytes). A calculadora normaliza internamente todos os valores de memória para bytes exatos, então as entradas em Mi e Gi se comparam e se totalizam corretamente sem nenhuma conversão manual.

Sim, a calculadora é totalmente gratuita. Ela roda inteiramente no seu navegador, sem servidor, sem conta e sem envio de dados — você não precisa se cadastrar nem fazer login. Você pode colar com segurança valores de recursos de manifestos internos porque nada sai do seu dispositivo.

Baseie as requests no uso observado em p95 ou p99 coletado com kubectl top durante um período representativo de 24 horas, e então defina os limits em aproximadamente duas a cinco vezes o valor da request. Requests altas demais desperdiçam capacidade de nó alocável; baixas demais deixam o pod sem recursos sob carga e provocam throttling de CPU ou OOMKills. Use a calculadora para totalizar os valores por contêiner considerando as réplicas antes de fixar números em um manifesto.

More free, private DevOps tools.

A Kubernetes Resource Calculator é mais uma ferramenta do OpsCanopy — uma copa crescente de validadores, conversores e testers baseados no navegador que nunca tocam um servidor.

Começando com Docker?  Leia o guia de Docker →

29 ferramentas gratuitas, todas capazes de funcionar offline — o opscanopy.com não exige cadastro e não envia nada.

Relacionados: o Base64 Encoder / Decoder e a Subnet Calculator, ou explore o diretório de ferramentas completo.

Fornecido como está, por conveniência; sempre confirme mudanças críticas de capacidade com sua própria autoridade. OpsCanopy é gratuito e aberto.