requestsとlimits — Pendingのまま動かない

Podがずっと Pending なのは、要求した資源が空いていないからです。requestsとlimitsの意味を確かめます。

前回: StatefulSetでDBを載せる — 3つに増やしたら壊れた

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の Kubernetesは「状態を宣言する」 — minikube入門 の続きとして、そこでは一度も書かなかった 「この Pod にメモリとCPUをいくつ渡すか」 だけを、実際に足りなくして確かめる回です。

この記事のコマンドは、すべて VM の中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。 前提: 本線の minikube入門 を終えて、kubectl get node が Ready を返すこと。 この記事はわざと Pod を落とします。 壊すのは自分で作った Pod だけで、VM やクラスタは壊しません。

ここまでの深掘りで作ってきた YAML には、書いていなかった欄がありました。

      containers:
        - name: nginx
          image: nginx:1.25

メモリもCPUも、一言も書いていません。 それでも動いていました。だから「書かなくていいもの」だと思っていました。

そのまま StatefulSet の回で MySQL を3つ立てたとき、2つの症状に順番に殴られました。

1つ目。Pod が Pending のまま、いつまでも動きません。

NAME    READY   STATUS    RESTARTS   AGE
db-0    0/1     Pending   0          6m

kubectl logs を打っても何も出ません。当然で、まだ一度も動いていないからです。

2つ目。今度は動いたのに、しばらくすると勝手に落ちます。

NAME    READY   STATUS      RESTARTS      AGE
db-0    0/1     OOMKilled   3 (20s ago)   4m

この2つが、まったく別の問題に見えていました。 片方は「起動しない」、もう片方は「起動したのに落ちる」です。調べる場所も別々に探しました。

同じ話でした。

Pending は「requests が大きすぎる」。 OOMKilled は「limits が小さすぎる」。 どちらも、さっき書かなかったあの欄の話です。

そして厄介なことに、この2つは逆方向に効きます。 Pending を直そうとして数字を小さくすると OOMKilled に寄り、OOMKilled を直そうとして大きくすると Pending に寄ります。片方だけ見ていると、行ったり来たりして終わりません。

この記事は、その2つの数字が何なのかを分けるところから始めます。

対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • requests と limits は名前が似ているだけで、役割も、見ている人も違うこと。ここを混同すると、この先の話が全部おかしくなる
  • requests は「置き場所を決めるための申告」で、スケジューラだけが見ていること。実際の使用量を制限しない
  • limits は「実際の上限」で、kubelet と cgroups が見ていること。スケジューラは見ていない
  • Pending の原因は Pod の中ではなくノード側にあること。kubectl describe node の Allocatable を読めば分かる
  • Allocatable は搭載量より小さいこと。システムの取り分が先に引かれている
  • メモリを超えると殺され、CPU を超えても殺されないこと。メモリは「圧縮できない」から殺すしかない
  • CPU の超過は「遅くなる」という形で現れること。スロットリングという
  • 1000m と 1 は同じ数字であること。Mi と M は別の数字であること
  • QoS クラスは自分で書くものではなく、requests と limits の書き方から自動で決まること。メモリが逼迫したとき、殺される順番になる
  • LimitRange と ResourceQuota で、名前空間ごとに上限を掛けられること。超える Pod は作成の時点で拒否される
  • 数字は測ってから決めるものであること。最初から limits を付けないという選択もある

この記事でやること

  1. requests と limits を対比して読む。どちらを誰が見ているかを先に分ける
  2. ノードの空きより大きい requests を書いて、わざと Pending を出す。describe pod の Events と describe node の Allocatable を読む
  3. limits.memory を小さくして、メモリを食うコマンドを走らせ、OOMKilled と終了コード 137 を出す
  4. limits.cpu を絞って、同じ処理の実行時間を測り、殺されずに遅くなるのを見る
  5. QoS の3クラスを3つとも作って、kubectl describe pod で確認する
  6. LimitRange と ResourceQuota を名前空間に掛けて、超える Pod が拒否されるのを見る
  7. kubectl top で実測してから数字を決める手順を通す
  8. 作ったものを全部片づける

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
requests(要求)「この Pod には最低これだけ要ります」という申告。置き場所を決めるためだけに使われる。実際の使用量は縛らない
limits(制限)「これ以上は使わせない」という実際の上限。超えたときの扱いはメモリとCPUで違う
スケジューラ新しい Pod をどのノードに置くか決める係。kube-scheduler という名前で動いている
kubelet各ノードの上で実際にコンテナを起動して面倒を見る係。limits を渡すのはこの人
Allocatable(割り当て可能量)そのノードでPod に配れる量。搭載量ではない。システムの取り分を引いた残り
OOMOut Of Memory。メモリが足りなくなった状態。カーネルがプロセスを選んで強制終了する
スロットリングわざと待たせて速度を抑えること。CPU の上限はこの形で効く
QoS クラスQuality of Service。メモリが足りなくなったとき、どの Pod から追い出すかの優先度。3段階ある
Eviction(退避)ノードが苦しくなったときに、kubelet が Pod を追い出すこと。OOM で殺されるのとは別の経路
名前空間(Namespace)クラスタの中を仕切る区画。同じ名前のリソースを別々に持てる
LimitRange1つの Pod・コンテナに対する上限と既定値を、名前空間に掛けるもの
ResourceQuota名前空間の合計に対する上限を掛けるもの。LimitRange とは対象が違う
metrics-serverいま実際にどれだけ使っているかを集める部品。これが無いと kubectl top は動かない

requests と limits は、役割が違う

まず、書き方だけ見ておきます。コンテナ1つごとに書きます。 Pod 全体ではありません。

      containers:
        - name: app
          image: nginx:1.25
          resources:
            requests:
              memory: "64Mi"
              cpu: "100m"
            limits:
              memory: "128Mi"
              cpu: "500m"

見た目がほとんど同じなので、私は「下限と上限」だと読みました。 それが間違いの元でした。

下限と上限ではありません。見ている人が違います。

requestslimits
何を言っているか「これだけ空いている場所に置いてくれ」「これ以上は使わせるな」
誰が見るかスケジューラ(置き場所を決めるとき、1回だけ)kubelet と cgroups(動いている間ずっと)
いつ効くかPod を置く瞬間だけ起動してから終わるまでずっと
足りないと何が起きるかPending。置く場所が無いので、そもそも起動しないメモリは OOMKilled、CPU はスロットリング
実際の使用量を縛るか縛らない。requests を超えて使える縛る。これが本当の天井
書かないとどうなるか0 扱い。どこにでも置けてしまう上限なし。ノードのメモリを食い尽くせる

この表の2行目が、いちばん大事なところでした。

requests は「予約」であって「配給」ではありません。 場所取りにだけ使われる数字で、実際に渡される量ではありません。

だから、こういうことが平気で起きます。

  • requests: 64Mi と書いた Pod が、実際には 500Mi 使っている(limits を書いていなければ、止められません)
  • ノードのメモリが実際にはガラガラなのに、Pending になる(requests の合計だけが埋まっているからです)

2つ目は、実際にやると気持ち悪いです。 free -h で見ればメモリは空いているのに、Kubernetes は「もう置けない」と言います。Kubernetes が見ているのは実測ではなく、申告の合計だからです。

ここから、それを自分で起こします。

requests が大きすぎて Pending になる

先に、ノードにいくら空いているか

わざと失敗させる前に、正解の値を見ておきます。

bash
$ kubectl describe node minikube

長いので、要るところだけ抜きます。

bash
$ kubectl describe node minikube | grep -A 6 "Capacity:"
Capacity:
  cpu:                2
  ephemeral-storage:  61202244Ki
  hugepages-2Mi:      0
  memory:             4014588Ki
  pods:               110
Allocatable:
bash
$ kubectl describe node minikube | grep -A 6 "Allocatable:"
Allocatable:
  cpu:                2
  ephemeral-storage:  56403987978
  hugepages-2Mi:      0
  memory:             3912188Ki
  pods:               110

2つあります。ここが引っかかりました。

欄意味
Capacityそのノードが積んでいる量。ハードウェア(VM に割り当てた分)そのもの
AllocatablePod に配れる量。Capacity からシステムの取り分を引いた残り

この例では、メモリが 4014588Ki に対して 3912188Ki。 約100MB少なくなっています。

Allocatable は必ず Capacity より小さくなります。 kubelet 自身、コンテナランタイム、OS が動く分が先に取ってあるからです。

「4GB積んでいるのだから 4Gi 要求できる」は間違いです。 実際に配れるのは、その手前までです。クラウドのマネージドな環境では、ここの差がもっと大きいこともあります(ノードあたり数百MB〜1GB近く引かれることがあります)。

[スクリーンショット: 01_node_capacity.png] kubectl describe node minikube の Capacity と Allocatable が両方写るところを撮ってください。2つの数字が違っていることが分かる形でお願いします。

いま、どれだけ埋まっているか

もう1つ、下のほうに大事な欄があります。

bash
$ kubectl describe node minikube | grep -A 12 "Allocated resources:"
Allocated resources:
  (Total limits may be over 100 percent, i.e., overcommitted.)
  Resource           Requests    Limits
  --------           --------    ------
  cpu                750m (37%)  0 (0%)
  memory             170Mi (4%)  170Mi (4%)
  ephemeral-storage  0 (0%)      0 (0%)
  hugepages-2Mi      0 (0%)      0 (0%)

この表を読めるかどうかが、Pending を自力で直せるかの分かれ目でした。

  • Requests の列 … これが埋まると、新しい Pod が置けなくなります。 空きは Allocatable - Requests
  • Limits の列 … 合計が Allocatable を超えても構いません。1行目に書いてあるとおりです

(Total limits may be over 100 percent, i.e., overcommitted.) 「limits の合計は100%を超えてよい」と、Kubernetes 自身が書いています。

オーバーコミット(超過割り当て)と言います。全員が同時に上限まで使うことはない、という前提です。requests のほうは超えられません。そこは実際に場所を取っているからです。

この例だと、メモリの空きはこうなります。

3912188Ki(Allocatable) − 170Mi(Requests) ≈ 3.6Gi

この 3.6Gi より大きい requests を書けば、置けなくなります。

わざと、置けない Pod を作る

bash
$ mkdir -p ~/k8s-res
$ cd ~/k8s-res
$ nano pending.yaml
apiVersion: v1
kind: Pod
metadata:
  name: too-big
spec:
  containers:
    - name: app
      image: nginx:1.25
      resources:
        requests:
          memory: "100Gi"
          cpu: "8"

100Gi のメモリと 8CPU を要求しています。 VM には 4GB / 2CPU しかありません。絶対に置けません。

bash
$ kubectl apply -f pending.yaml
pod/too-big created

created と出ます。エラーになりません。 ここで一度つまずきました。

作られたのは「Pod という予定」であって、「動いているコンテナ」ではありません。 置き場所が決まらないだけで、オブジェクトとしては存在します。

bash
$ kubectl get pod too-big
NAME      READY   STATUS    RESTARTS   AGE
too-big   0/1     Pending   0          25s

Pending のまま止まります。 何分待っても変わりません。ContainerCreating にすらなりません。

logs は打たない。describe を打つ

私はここで反射的に kubectl logs を打ちました。

bash
$ kubectl logs too-big
(何も表示されずに、プロンプトに戻る)

当たり前でした。一度も動いていないので、ログはありません。

Pending のときに読むのは logs ではなく describe の Events です。

bash
$ kubectl describe pod too-big

最後のほうだけ出します。

bash
$ kubectl describe pod too-big | tail -8
Events:
  Type     Reason            Age                From               Message
  ----     ------            ----               ----               -------
  Warning  FailedScheduling  62s                default-scheduler  0/1 nodes are available: 1 Insufficient cpu, 1 Insufficient memory. preemption: 0/1 nodes are available: 1 No preemption victims found for incoming pod.

ここに全部書いてありました。

断片意味
FailedScheduling置き場所が決まらなかった。起動に失敗したのではない
default-schedulerスケジューラが言っている。kubelet ではない
0/1 nodes are available1台あるうち0台が候補。つまり全滅
Insufficient cpu / Insufficient memoryrequests に対して空きが足りない。この2語がそのまま原因
No preemption victims found押しのけられる Pod も居なかった(優先度の話。ここでは扱いません)

[スクリーンショット: 02_pending_events.png] kubectl describe pod too-big の Events の部分を撮ってください。Insufficient cpu と Insufficient memory の行が読める形でお願いします。

直す

Pod 側の YAML の中を疑っても、何も見つかりません。 イメージも書き方も正しいからです。見るのはノード側でした。

bash
$ kubectl describe node minikube | grep -A 12 "Allocated resources:"

この Requests 列の空きに収まる数字に直す。 それだけです。

bash
$ kubectl delete -f pending.yaml
$ nano pending.yaml
apiVersion: v1
kind: Pod
metadata:
  name: too-big
spec:
  containers:
    - name: app
      image: nginx:1.25
      resources:
        requests:
          memory: "64Mi"
          cpu: "100m"
bash
$ kubectl apply -f pending.yaml
$ kubectl get pod too-big
NAME      READY   STATUS    RESTARTS   AGE
too-big   1/1     Running   0          8s

動きました。

Pending の直し方は2つしかありません。 requests を小さくするか、ノードを増やす(大きくする)か。 Pod の中身をいじっても、絶対に直りません。

片づけておきます。

bash
$ kubectl delete -f pending.yaml

Pending の原因は requests だけではない

ここは正直に書いておきます。 この記事では requests が原因の Pending だけを扱いますが、Pending は他の理由でも起きます。

Events に出る言葉だいたいの原因
Insufficient cpu / Insufficient memoryこの記事の話。requests に空きが足りない
pod has unbound immediate PersistentVolumeClaimsストレージが用意できていない。ストレージの回で扱いました
node(s) had untolerated taintノード側が受け入れを拒否している(別の回で扱います)

共通しているのは、describe の Events に理由が書いてあることです。 読む場所さえ同じなら、原因が違っても迷いません。

メモリを超えると、殺される

次は limits です。今度は起動します。起動してから死にます。

bash
$ nano oom.yaml
apiVersion: v1
kind: Pod
metadata:
  name: oom-test
spec:
  restartPolicy: Never
  containers:
    - name: eater
      image: polinux/stress
      command: ["stress"]
      args: ["--vm", "1", "--vm-bytes", "200M", "--vm-hang", "1"]
      resources:
        requests:
          memory: "50Mi"
        limits:
          memory: "100Mi"

やっていることは単純です。

行意味
image: polinux/stress負荷をかけるためだけの小さいイメージ。stress というコマンドが入っている
--vm 1 --vm-bytes 200M200MB のメモリを確保しにいく
--vm-hang 1確保したまま掴んで離さない
limits.memory: "100Mi"上限は 100Mi。200MB は入らない
restartPolicy: Never落ちても再起動しない。死んだ状態を観察したいので

「100の入れ物に200を入れる」だけです。

bash
$ kubectl apply -f oom.yaml
$ kubectl get pod oom-test -w
NAME       READY   STATUS              RESTARTS   AGE
oom-test   0/1     ContainerCreating   0          2s
oom-test   0/1     OOMKilled           0          9s

Ctrl + C で止めます。

一度は起動してから OOMKilled になりました(Running の時間が短く、-w に出ないこともあります)。 さっきの Pending と違い、一度は動いています。

終了コード137

bash
$ kubectl describe pod oom-test | grep -A 6 "State:"
    State:          Terminated
      Reason:       OOMKilled
      Exit Code:    137
      Started:      Fri, 26 Sep 2026 10:41:12 +0900
      Finished:     Fri, 26 Sep 2026 10:41:19 +0900
    Ready:          False

Reason: OOMKilled、Exit Code: 137。

この数字は Docker深掘りの docker run の回で一度見ています。 そこでは --memory を付けたコンテナが同じ終わり方をしました。まったく同じものです。

137 = 128 + 9。9 は SIGKILL の番号です。 カーネルが SIGKILL で強制終了した、という意味です。

SIGKILL は受け取った側が拒否できません。 後片づけもできません。「終了処理を書いておけば安全に終われる」ということが、ここだけはできません。

[スクリーンショット: 03_oomkilled.png] kubectl describe pod oom-test の State の部分を撮ってください。Reason: OOMKilled と Exit Code: 137 の2行が読める形でお願いします。

ログには何も残らない

bash
$ kubectl logs oom-test
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd

途中で切れています。 「メモリが足りません」という行はありません。

OOM で殺されたとき、アプリのログには何も残らないのが普通です。 アプリが気づく前に、外から殺されているからです。

これが「理由なく落ちる」の正体でした。 アプリのログを何度読み直しても、原因は書かれていません。kubectl describe pod の State を見るのが、確認手順の1つ目になります。

なぜ「絞る」ではなく「殺す」のか

ここが、この記事でいちばん納得したところです。

メモリは「圧縮できない資源」だからです。

CPU なら「順番待ちさせる」ができます。待たせれば、時間はかかっても仕事は終わります。

メモリは、そうはいきません。「200MB 要る」と言っているプロセスに 100MB だけ渡して、待たせるということができません。足りないなら、そのプロセスは進めません。

だから、選択肢は2つしかありません。

やり方結果
ノード全体のメモリを食わせる他の Pod も、kubelet も巻き込んで、ノードごと不安定になる
超えた1つを殺す被害がその Pod だけで済む

Kubernetes は後者を選んでいます。 limits.memory は「ここまでで殺してよい」という宣言でした。殺されることが事故なのではなく、殺されないほうが事故です。

この判断をしているのは Kubernetes ではなく Linux カーネルです。 cgroups でメモリの上限が掛けられていて、超えたらカーネルが殺します。その仕組みは コンテナの正体は名前空間とcgroups — Linux深掘り で見たとおりで、Kubernetes は limits の数字を cgroups に渡しているだけです。新しい仕組みは、ここには何もありません。

直す

200MB 使うものに 100Mi しか渡していないのだから、上げます。

bash
$ kubectl delete -f oom.yaml
$ nano oom.yaml
        limits:
          memory: "300Mi"
bash
$ kubectl apply -f oom.yaml
$ kubectl get pod oom-test
NAME       READY   STATUS    RESTARTS   AGE
oom-test   1/1     Running   0          15s

今度は落ちません。

ただし、これを「limits を上げれば直る」と覚えると危険です。 アプリ側がメモリを漏らしている場合、上げてもいずれ同じところに来ます。 そのときは RESTARTS の数字が増え続けます。

bash
$ kubectl get pod
NAME       READY   STATUS             RESTARTS        AGE
leaky      0/1     CrashLoopBackOff   7 (2m14s ago)   28m

RESTARTS が増え続けながら OOMKilled を繰り返しているときは、limits ではなくアプリを疑います。 一度上げて直るなら見積もり違い、上げても時間が延びるだけならメモリリークです。

bash
$ kubectl delete -f oom.yaml

CPU を超えても、殺されない

メモリと同じつもりで CPU を絞ると、まったく違うことが起きます。

測るための処理を用意する

まず、制限なしで走らせて時間を測ります。

bash
$ nano cpu-free.yaml
apiVersion: v1
kind: Pod
metadata:
  name: cpu-free
spec:
  restartPolicy: Never
  containers:
    - name: burner
      image: busybox:1.36
      command: ["sh", "-c"]
      args:
        - "time sh -c 'i=0; while [ $i -lt 300000 ]; do i=$((i+1)); done'"

やっているのは足し算を30万回です。中身に意味はありません。 大事なのは、毎回まったく同じ量の仕事だということです。

bash
$ kubectl apply -f cpu-free.yaml
$ kubectl wait --for=jsonpath='{.status.phase}'=Succeeded pod/cpu-free --timeout=180s
$ kubectl logs cpu-free
real	0m 3.42s
user	0m 3.29s
sys	0m 0.12s

約3.4秒でした。 kubectl wait はその状態になるまで待つコマンドで、Succeeded(正常終了)まで待っています。

同じ処理を、CPU を絞って走らせる

bash
$ nano cpu-limited.yaml
apiVersion: v1
kind: Pod
metadata:
  name: cpu-limited
spec:
  restartPolicy: Never
  containers:
    - name: burner
      image: busybox:1.36
      command: ["sh", "-c"]
      args:
        - "time sh -c 'i=0; while [ $i -lt 300000 ]; do i=$((i+1)); done'"
      resources:
        requests:
          cpu: "50m"
        limits:
          cpu: "100m"

違いは limits.cpu: "100m" だけです。

bash
$ kubectl apply -f cpu-limited.yaml
$ kubectl wait --for=jsonpath='{.status.phase}'=Succeeded pod/cpu-limited --timeout=300s
$ kubectl logs cpu-limited
real	0m 34.18s
user	0m 3.31s
sys	0m 0.14s

ここを見比べてください。

制限なしlimits.cpu: 100m
real(実際の経過時間)3.42s34.18s
user(CPUを使った時間)3.29s3.31s
終わり方SucceededSucceeded(殺されていない)

2つ、はっきりしました。

1. 約10倍遅くなりました。 100m は 1CPU の 10分の1 なので、ちょうど計算が合います。 2. user はほとんど変わっていません。 仕事の量は減っていません。

real だけが伸びて user が伸びない。 これは「待たされていた」ということです。計算そのものは同じだけやって、同じだけ終わっています。

そして、殺されていません。 STATUS を見ます。

bash
$ kubectl get pod cpu-limited
NAME          READY   STATUS      RESTARTS   AGE
cpu-limited   0/1     Completed   0          40s

Completed。正常終了です。 メモリのときは OOMKilled でした。同じ「上限を超えた」なのに、扱いがまったく違います。

[スクリーンショット: 04_cpu_throttle.png] 制限なしと limits.cpu: 100m の kubectl logs の結果を、2つ並べて撮ってください。 real の差が読める形でお願いします。

スロットリング

この「待たされる」ことをスロットリングと言います。

CPU は「圧縮できる資源」です。 足りなければ待たせればよく、待てば仕事は終わります。だから殺す必要がありません。

待たされた回数は、記録に残っています。 cgroups が数えているので、コンテナの中から読めます。

bash
$ nano cpu-stat.yaml
apiVersion: v1
kind: Pod
metadata:
  name: cpu-stat
spec:
  restartPolicy: Never
  containers:
    - name: burner
      image: busybox:1.36
      command: ["sh", "-c"]
      args:
        - "i=0; while [ $i -lt 300000 ]; do i=$((i+1)); done; cat /sys/fs/cgroup/cpu.stat"
      resources:
        limits:
          cpu: "100m"
bash
$ kubectl apply -f cpu-stat.yaml
$ kubectl wait --for=jsonpath='{.status.phase}'=Succeeded pod/cpu-stat --timeout=300s
$ kubectl logs cpu-stat
usage_usec 3387412
user_usec 3301885
system_usec 85527
nr_periods 341
nr_throttled 338
throttled_usec 30751904

読み方はこうです。

欄意味
nr_periodsCPU の割り当てを見る区切りが何回あったか。既定では100ミリ秒に1回
nr_throttledそのうち何回、上限に触れて止められたか。341回中338回
throttled_usec止められていた合計時間(マイクロ秒)。約30.7秒

さっきの real と user の差(約30.8秒)と、ほぼ一致しています。

「遅い」の中身が、数字で出ました。 止められていた時間が、そのまま伸びた時間です。

この cpu.stat は Linux の cgroups の機能そのものです(cgroups の回で見たものと同じファイルです)。Kubernetes は limits.cpu の数字を、ここに変換して渡しているだけでした。

/sys/fs/cgroup/cpu.stat が読めるのは cgroup v2 の場合です。 古い環境では場所が違います(cpu,cpuacct の下)。読めなかったら、この確認だけ飛ばして構いません。 本筋は real と user の差です。

単位の読み方

ここで一度、単位を整理します。私はここで実際に間違えました。

CPU の単位

書き方意味
1CPU 1個ぶん(1コアを100%使える)
1000m1 とまったく同じ。 m は milli(1000分の1)
500m0.5個ぶん。0.5 と書いても同じ
100m0.1個ぶん。10分の1
44個ぶん。2コアのノードには置けない

1000m と 1 は同じです。 1000m を「1000個」と読むと3桁ずれます。 m は「ミリ」で、CPU にしか使いません。

メモリの単位

書き方実際の値読み
128Mi128 × 1024 × 1024 = 134,217,728 バイト2の累乗。これを使う
128M128 × 1000 × 1000 = 128,000,000 バイト10の累乗。約5%小さい
1Gi1024Mi = 1,073,741,824 バイト2の累乗
1G1,000,000,000 バイト10の累乗
134217728単位なしはバイト読みにくいので使わない

Mi と M は別の数字です。 i は binary(2進)の意味です。 メモリでは Mi / Gi を使ってください。

なぜ揃えるかというと、ノードの Allocatable が Ki で出るからです。Mi で書いておけば、そのまま足し引きできます。M と Mi を混ぜると、計算が数%ずつずれて、あとで合いません。

m と Mi は、字面が似ていますが無関係です。 小文字の m は CPU のミリ、大文字の M はメモリのメガです。100m のメモリ、と書くと 0.1バイトの意味になります(実際に書けてしまいます)。

片づけます。

bash
$ kubectl delete -f cpu-free.yaml -f cpu-limited.yaml -f cpu-stat.yaml

QoS クラス — 誰から殺されるか

requests と limits の書き方によって、Pod には自動で階級が付きます。 QoS Class と言います。

自分で書く欄ではありません。 書き方から Kubernetes が勝手に決めます。

クラス条件意味
Guaranteedすべてのコンテナで、requests と limits が両方あり、値が同じ(CPU もメモリも)最優先。最後まで残す
Burstablerequests か limits がどれか1つでも書いてあるが、Guaranteed の条件は満たさない中間。requests を超えて使っている Pod から狙われる
BestEffortrequests も limits も、1つも書いていない最下位。真っ先に追い出される

3つとも作って、実際に確認します。

bash
$ nano qos.yaml
apiVersion: v1
kind: Pod
metadata:
  name: qos-guaranteed
spec:
  containers:
    - name: app
      image: nginx:1.25
      resources:
        requests:
          memory: "64Mi"
          cpu: "100m"
        limits:
          memory: "64Mi"
          cpu: "100m"
---
apiVersion: v1
kind: Pod
metadata:
  name: qos-burstable
spec:
  containers:
    - name: app
      image: nginx:1.25
      resources:
        requests:
          memory: "64Mi"
        limits:
          memory: "128Mi"
---
apiVersion: v1
kind: Pod
metadata:
  name: qos-besteffort
spec:
  containers:
    - name: app
      image: nginx:1.25

--- は 1つのファイルに複数のリソースを書くときの区切りです。3つの Pod が1ファイルに入っています。

bash
$ kubectl apply -f qos.yaml
$ kubectl get pod
NAME             READY   STATUS    RESTARTS   AGE
qos-besteffort   1/1     Running   0          10s
qos-burstable    1/1     Running   0          10s
qos-guaranteed   1/1     Running   0          10s

3つとも動いています。見た目では区別が付きません。

bash
$ kubectl describe pod qos-guaranteed | grep QoS
$ kubectl describe pod qos-burstable | grep QoS
$ kubectl describe pod qos-besteffort | grep QoS
QoS Class:                   Guaranteed
QoS Class:                   Burstable
QoS Class:                   BestEffort

3つとも違います。 まとめて見るならこちらのほうが楽です。

bash
$ kubectl get pod -o custom-columns=NAME:.metadata.name,QOS:.status.qosClass
NAME             QOS
qos-besteffort   BestEffort
qos-burstable    Burstable
qos-guaranteed   Guaranteed

[スクリーンショット: 05_qos_class.png] kubectl get pod -o custom-columns=NAME:.metadata.name,QOS:.status.qosClass の結果を撮ってください。3つのクラスが並んでいる形でお願いします。

どれから殺されるか

ノードのメモリが逼迫すると、kubelet は Pod を追い出し始めます(Eviction)。その順番が、この階級です。

1. BestEffort        ← 真っ先
2. Burstable のうち、requests を超えて使っているもの
3. Burstable のうち、requests に収まっているもの
4. Guaranteed        ← 最後

ここで、requests のもう1つの意味が分かりました。

requests は「置き場所の申告」であると同時に、「ここまでは守ってもらえる線」でもあります。 requests に収まって使っている限り、追い出される順番は後ろになります。

BestEffort(何も書いていない Pod)が真っ先に落ちるというのが、この節の実用的な結論です。「面倒だから resources を書かなかった Pod」が、いちばん危ないということです。

これは「ノードが苦しくなったとき」の話で、山場②の OOMKilled とは別の経路です。 混ざりやすいので分けておきます。

OOMKilledEviction(退避)
誰がLinux カーネルkubelet
何が原因その Pod が自分の limits を超えたノード全体のメモリが足りなくなった
どうなるそのコンテナが SIGKILL。137Pod ごと追い出され、別のノードへ(居れば)
describe に出る言葉Reason: OOMKilledReason: Evicted

自分の分を使いすぎたのか、隣が使いすぎたのか。 見る欄が違います。

bash
$ kubectl delete -f qos.yaml

LimitRange と ResourceQuota — 名前空間に上限を掛ける

ここまでは「1つの Pod に何を書くか」でした。 現実には、書き忘れる人が出ます。 BestEffort の Pod が1つ紛れ込むだけで、ノードを食い尽くされます。

そこで、名前空間の側から縛ります。 2つあって、対象が違います。

LimitRangeResourceQuota
何に効くかPod / コンテナ1つずつ名前空間の合計
できること既定値を入れる・1つあたりの最大最小を決める合計の上限を決める・resources の記載を必須にする
例えると「1人あたり3個まで」「全員で100個まで」

両方作って、確かめます。 作業用の名前空間を切ります。

bash
$ kubectl create namespace res-demo
namespace/res-demo created

LimitRange — 書き忘れに既定値を入れる

bash
$ nano limitrange.yaml
apiVersion: v1
kind: LimitRange
metadata:
  name: default-limits
  namespace: res-demo
spec:
  limits:
    - type: Container
      default:
        memory: "128Mi"
        cpu: "200m"
      defaultRequest:
        memory: "64Mi"
        cpu: "100m"
      max:
        memory: "512Mi"
        cpu: "1"
欄意味
type: Containerコンテナ1つずつに掛ける
defaultlimits を書かなかったときに入る値
defaultRequestrequests を書かなかったときに入る値
max1コンテナが要求できる上限。超えると拒否される
bash
$ kubectl apply -f limitrange.yaml

何も書いていない Pod を作ります。

bash
$ kubectl run naked --image=nginx:1.25 -n res-demo
$ kubectl get pod naked -n res-demo -o jsonpath='{.spec.containers[0].resources}'
$ echo
{"limits":{"cpu":"200m","memory":"128Mi"},"requests":{"cpu":"100m","memory":"64Mi"}}

書いていないのに、入っています。 LimitRange が作成の時点で書き足しています。

bash
$ kubectl describe pod naked -n res-demo | grep QoS
QoS Class:                   Burstable

BestEffort ではなくなりました。 これが LimitRange の一番の効き目でした。

書き忘れが BestEffort にならなくなります。 「真っ先に殺される Pod」が、名前空間から消えます。

max を超えると拒否される

bash
$ nano too-much.yaml
apiVersion: v1
kind: Pod
metadata:
  name: too-much
  namespace: res-demo
spec:
  containers:
    - name: app
      image: nginx:1.25
      resources:
        requests:
          memory: "64Mi"
        limits:
          memory: "2Gi"

max は 512Mi なのに、2Gi を要求しています。

bash
$ kubectl apply -f too-much.yaml
Error from server (Forbidden): error when creating "too-much.yaml": pods "too-much" is forbidden: maximum memory usage per Container is 512Mi, but limit is 2Gi

Pending になりません。作成そのものが拒否されます。

山場①と、ここが違います。

requests が大きすぎるLimitRange の max を超える
いつ弾かれるか作られてから、置き場所探しで失敗作られる前に拒否
kubectl get pod に出るか出る(Pending で)出ない。存在しない
メッセージInsufficient memory(Events)Forbidden(コマンドの返り)

Forbidden はその場で返ってきます。 describe を見に行く必要がありません。気づける速さが違います。

[スクリーンショット: 06_limitrange_forbidden.png] kubectl apply -f too-much.yaml が Forbidden で拒否されているところを撮ってください。

ResourceQuota — 合計を縛る

bash
$ nano quota.yaml
apiVersion: v1
kind: ResourceQuota
metadata:
  name: demo-quota
  namespace: res-demo
spec:
  hard:
    requests.memory: "256Mi"
    requests.cpu: "500m"
    limits.memory: "512Mi"
    pods: "5"

この名前空間の全員で、requests のメモリ合計 256Mi まで、Pod は5個まで、という意味です。

bash
$ kubectl apply -f quota.yaml
$ kubectl describe quota demo-quota -n res-demo
Name:            demo-quota
Namespace:       res-demo
Resource         Used    Hard
--------         ----    ----
limits.memory    128Mi   512Mi
pods             1       5
requests.cpu     100m    500m
requests.memory  64Mi    256Mi

Used と Hard が並んでいます。 さっきの naked の分(64Mi)が、もう乗っています。

合計を超える Pod を作ってみます。

bash
$ nano over-quota.yaml
apiVersion: v1
kind: Pod
metadata:
  name: over-quota
  namespace: res-demo
spec:
  containers:
    - name: app
      image: nginx:1.25
      resources:
        requests:
          memory: "256Mi"
        limits:
          memory: "256Mi"

残りは 256Mi - 64Mi = 192Mi しかありません。

bash
$ kubectl apply -f over-quota.yaml
Error from server (Forbidden): error when creating "over-quota.yaml": pods "over-quota" is forbidden: exceeded quota: demo-quota, requested: requests.memory=256Mi, used: requests.memory=64Mi, limited: requests.memory=256Mi

requested / used / limited の3つが全部書いてあります。 何がいくら足りないかを、こちらで計算する必要がありません。

ResourceQuota を掛けると、記載が必須になる

ここは踏んでおくべき落とし穴です。

ResourceQuota に requests.memory を書くと、その名前空間の Pod は全員 requests.memory を書かなければならなくなります。 書いていないと、合計が数えられないからです。

さっきは LimitRange が既定値を入れてくれたので気づきませんでした。 LimitRange を消すと、こうなります。

bash
$ kubectl delete limitrange default-limits -n res-demo
$ kubectl run naked2 --image=nginx:1.25 -n res-demo
Error from server (Forbidden): pods "naked2" is forbidden: failed quota: demo-quota: must specify limits.memory for: naked2; requests.cpu for: naked2; requests.memory for: naked2

must specify と言われます。

ResourceQuota だけを掛けると、既存の YAML が軒並み通らなくなります。 LimitRange を先に(または同時に)置いて、既定値を入れておくのが定石です。

この2つはセットで使うものでした。片方だけ入れて事故る、が定番のようです。

戻しておきます。

bash
$ kubectl apply -f limitrange.yaml

どう決めるか — 測ってから決める

ここまでで書き方は分かりましたが、「いくつにするか」は分かりません。 私はここが一番知りたいところでした。

答えは「測る」でした。 勘で書いた数字は、必ず山場①か山場②のどちらかに落ちます。

metrics-server を入れる

bash
$ kubectl top pod
error: Metrics API not available

素の状態では動きません。 実測を集める部品が別に要ります。

minikube ならアドオンで入ります。

bash
$ minikube addons enable metrics-server
The 'metrics-server' addon is enabled

集まるまで1〜2分かかります。 すぐ打つと、まだ何も出ません。

bash
$ kubectl top node
NAME       CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
minikube   241m         12%    1187Mi          31%
bash
$ kubectl top pod -n res-demo
NAME    CPU(cores)   MEMORY(bytes)
naked   1m           3Mi

naked は nginx が1つ動いているだけなので、実測 3Mi です。 LimitRange が入れた既定値は requests: 64Mi でした。20倍取ってあります。

[スクリーンショット: 07_kubectl_top.png] kubectl top node と kubectl top pod の結果を撮ってください。

kubectl top はいまこの瞬間の値です。 ピークは映りません。本気で決めるなら、時間で追える仕組み(本線の Prometheusは取りに行く — 監視とログの入口)が要ります。 ここでは「桁を知る」ために使います。

決め方の順番

自分がいま使っている手順です。

  1. まず limits を付けずに動かす(requests だけ、控えめに書く)
  2. kubectl top pod を何度か見て、実測の桁を知る
  3. requests は「普段の使用量」に寄せる(置き場所の申告なので、実態に近いほど詰められる)
  4. limits は「ピークの2倍くらい」から始める(狭すぎると OOMKilled、広すぎると意味がない)
  5. OOMKilled が出たら上げる。出ないなら、次は下げてみる

この順番の理由は、山場②と③で見たとおりです。

requests を間違えると Pending(動かない)。 limits.memory を間違えると OOMKilled(落ちる)。 limits.cpu を間違えると、遅くなるだけで気づけない。

いちばん危ないのは3つ目です。 落ちないので、誰も気づきません。「なんとなく遅い」の原因が limits.cpu だった、というのは実際にありました。

最初は limits を付けない、という選択

教科書的には「必ず両方書け」ですが、私はいつもそうしていません。

場面どうするか
手元の学習用クラスタlimits を付けない。 何も落ちないほうが、学ぶ邪魔にならない
requests だけ書く置き場所の申告はする。 BestEffort を避けられる
人が使うもの両方書く。 隣を巻き込まないため
メモリ量が読めない新しいアプリまず limits 無しで測る。 測る前に付けると、測る前に死ぬ

limits を書かないことのリスクは「隣を巻き込むこと」です。 1人で使っている VM の中で、巻き込む隣は居ません。

逆に、requests は早めに書いたほうが得です。書かないと BestEffort になり、ノードが苦しくなったとき真っ先に消えます。 書くコストはほぼゼロです。

「両方必ず書く」ではなく、「requests は書く、limits は測ってから」 が、いまの自分の結論です。

つまずいたところ

1. Pending の原因を Pod の中に探し続けた

kubectl describe pod は打っていました。 ただ、上のほうの Containers: や Volumes: ばかり読んでいて、いちばん下の Events を読んでいませんでした。

Insufficient memory の一言がそこにありました。describe は下から読む、を覚えました。エラーの読み方としては、本線の エラーは下から読む と同じことをしていました。

2. kubectl apply が成功したので、動いたと思った

pod/too-big created

created を見て安心して、次の作業に移りました。 30分後に見たら Pending のままでした。

created は「オブジェクトを受け付けた」であって「動いた」ではありません。

apply のあとは必ず kubectl get pod を見る、を手順に足しました。

3. requests を「割り当てられる量」だと思っていた

requests: 64Mi と書いた Pod が、kubectl top pod で 200Mi 使っているのを見て混乱しました。「64Mi しか渡していないはずなのに」と思いました。

渡していません。申告しただけでした。 requests は場所取りの数字で、実際の使用量を1バイトも制限しません。 制限するのは limits だけです。

この誤解のせいで、limits を書かない Pod が「64Mi しか使わない安全な Pod」に見えていました。 実際には上限なしでした。

4. OOMKilled をアプリのバグだと思ってログを読み続けた

ログには何も残っていませんでした。 「異常終了したのにログが正常なままで終わっている」のが不気味で、アプリ側の書き方を疑って何時間か使いました。

SIGKILL は拒否できないので、終了処理が走りません。 ログが途中で切れているのが正常でした。kubectl describe pod の State を見れば1行で分かりました。

5. limits.cpu: 100m を「100個」と読んだ

恥ずかしい間違いですが、書いておきます。 100m を見て「100CPU? そんなに要らない」と思い、10m に直しました。そうしたら、さらに10倍遅くなりました。

m はミリで、100m は 0.1個です。 1000m = 1。メモリの M(メガ)と字が同じで、まったく別物です。

6. CPU を絞ったのに気づかず、「なんとなく遅い」で放置した

メモリと違って、何も出ません。 STATUS は Running のままで、RESTARTS も増えません。エラーもログも出ません。

cpu.stat の nr_throttled を見て初めて分かりました。 341回中338回止められていました。

CPU の制限は「静かに」効きます。 落ちないので、監視していないと何年でも気づきません。

7. ResourceQuota を先に入れて、既存の Pod が全部作れなくなった

名前空間に ResourceQuota を掛けたら、それまで動いていた YAML が must specify limits.memory で通らなくなりました。

ResourceQuota に requests.memory を書いた瞬間、その名前空間の全 Pod に記載が必須になります。 合計を数えられないからです。

LimitRange を先に置いて既定値を入れておけば、これは起きません。 順番が逆でした。

8. ノードのメモリは空いているのに Pending だった

bash
$ free -h
               total        used        free      shared  buff/cache   available
Mem:           3.8Gi       1.2Gi       1.9Gi        12Mi       800Mi       2.4Gi

2.4Gi 空いています。 それでも Insufficient memory でした。

Kubernetes が見ているのは実測ではなく、requests の合計です。 kubectl describe node の Allocated resources に、実際には使われていない予約が積み上がっていました。

free と kubectl describe node は、別のものを数えています。 Pending を調べるときに free を見ても、何も分かりません。

大きすぎる requests を書いた Pod が1つあるだけで、ノードの空きが「予約済み」で埋まります。 そういう Pod を探すには、こうします。

bash
$ kubectl get pod -A -o custom-columns=NS:.metadata.namespace,NAME:.metadata.name,MEMREQ:.spec.containers[*].resources.requests.memory

実測ではなく申告を一覧にするので、犯人がすぐ見つかります。

後片づけ

作ったものを消します。 名前空間ごと消すのが一番速いです。

bash
$ kubectl delete namespace res-demo
namespace "res-demo" deleted

名前空間を消すと、その中の Pod も LimitRange も ResourceQuota も全部消えます。 個別に消す必要はありません。戻ってくるまで少し時間がかかります。

default に残っているものを消します。

bash
$ cd ~/k8s-res
$ kubectl delete -f oom.yaml --ignore-not-found
$ kubectl delete -f cpu-free.yaml -f cpu-limited.yaml -f cpu-stat.yaml --ignore-not-found
$ kubectl delete -f qos.yaml --ignore-not-found
$ kubectl delete -f pending.yaml --ignore-not-found

--ignore-not-found はもう無いものを指定してもエラーにしないという指定です。片づけのときに便利です。

残っていないか確認します。

bash
$ kubectl get pod
$ kubectl get ns
No resources found in default namespace.
NAME              STATUS   AGE
default           Active   5h
kube-node-lease   Active   5h
kube-public       Active   5h
kube-system       Active   5h

res-demo が消えていれば片づいています。

metrics-server を戻したいときは、こうです。入れたままでも困りません(少しメモリを使います)。

bash
$ minikube addons disable metrics-server

minikube ごと止めるなら、こうです。

bash
$ minikube stop

消さずに止めるだけなので、次回 minikube start で続きから使えます。

まとめ

理解できたこと。

  • Pending と OOMKilled は、まったく別の症状に見えて、どちらも同じ2つの数字の話だった。 片方だけ見て数字を動かすと、もう片方に落ちる
  • requests と limits は下限と上限ではない。見ている人が違う。 requests はスケジューラが置き場所を決めるときだけ、limits はkubelet と cgroups が動いている間ずっと
  • requests は実際の使用量を1バイトも制限しない。 「64Mi と書いたから 64Mi しか使わない」は完全な誤解。制限するのは limits だけ
  • Pending の原因は Pod の中には無い。 kubectl describe pod の Events に Insufficient cpu / Insufficient memory と書いてある。直し方は requests を下げるか、ノードを増やすかの2つだけ
  • Allocatable は Capacity より小さい。 システムの取り分が先に引かれている。「4GB積んだから 4Gi 要求できる」は通らない
  • free で空いていても Pending になる。 Kubernetes が数えているのは実測ではなく requests の合計
  • メモリを超えると殺される(OOMKilled / 終了コード137)。CPU を超えても殺されない(スロットリング)。 メモリは圧縮できない資源なので、待たせることができず、殺すしかない
  • CPU の制限は real だけが伸びて user は伸びない形で現れる。仕事は減っていない、待たされているだけ。 cpu.stat の nr_throttled に回数が残っている
  • CPU の制限は静かに効く。 落ちないので、見ていないと気づけない。いちばん見つけにくい
  • 1000m と 1 は同じ。Mi と M は違う。 m は CPU のミリ、M はメモリのメガ。字が似ているだけで無関係
  • QoS クラスは自分で書かない。requests と limits の書き方から決まる。 何も書かない Pod は BestEffort になり、ノードが苦しくなったとき真っ先に追い出される
  • OOMKilled(カーネルが、自分の限度超過で)と Evicted(kubelet が、ノード全体の逼迫で)は別の経路。 見る欄が違う
  • LimitRange は1つあたり、ResourceQuota は合計。 ResourceQuota を単体で入れると、記載必須になって既存の YAML が通らなくなる。LimitRange とセットで入れる
  • 超過の弾かれ方が2種類ある。 requests が大きすぎる → 作られてから Pending。LimitRange の max 超え → 作られる前に Forbidden
  • 数字は測ってから決める。 kubectl top には metrics-server が要る。最初は limits を付けずに測るという選択もあり、requests だけは早めに書いておくのが得

この回でいちばん効いたのは、limits.cpu を絞った Pod が Completed で正常終了したのを見たことでした。 メモリと同じつもりで「超えたら死ぬ」と思っていたので、死なずに10倍遅くなって、しかも仕事はきっちり終わっているのが意外でした。「圧縮できるかどうか」で扱いが変わる、というのが、この記事で拾った一番大きい考え方です。

参考リンク


次に読む

この記事は 【深掘り】Kubernetes の 9 / 15 本目です。

記事
← 前の記事StatefulSetでDBを載せる — 3つに増やしたら壊れた
→ 次の記事Podのスケジューリング — 全部同じノードに載った

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

DevOps›Kubernetes — Resource Management
  • requests と limits の役割の違い
  • QoS クラス / LimitRange / ResourceQuota

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次