Podのスケジューリング — 全部同じノードに載った

この記事はわざとノードに札を貼り、Pod をわざと Pending にし、動いている Pod をわざと追い出します。 最後の「後片づけ」まで必ずやってください。貼った札を外し忘れると、翌日から Pod が置けなくなります。

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の 1台落としてもPodは移る — kubeadmで組む3台クラスタ の続きとして、「Pod がどのノードに置かれるかは、誰がどう決めているのか」だけを、実際に動かして確かめます。

前回: requestsとlimits — Pendingのまま動かない

この記事のコマンドは、すべてVMの中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。

前提: 本線の 1台落としてもPodは移る — kubeadmで組む3台クラスタを終えていて、kubectl get nodes で3台とも Ready になっていること。 1台しかない minikube でも大半は動きます。 ただし「散らばる」ところは複数台ないと見えません。 その場合の読み替えは準備の節に書きました。

3台のクラスタで、Deployment を1つ作りました。レプリカは3つです。

bash
$ kubectl get pod -o wide
NAME                   READY   STATUS    RESTARTS   AGE   IP           NODE
web-5d8c9f7b4d-2xk9p   1/1     Running   0          40s   10.244.1.7   w1
web-5d8c9f7b4d-8mtqz   1/1     Running   0          40s   10.244.1.8   w1
web-5d8c9f7b4d-l4vnc   1/1     Running   0          40s   10.244.1.9   w1

3つとも w1 です。 w2 は空です。

私はこれを見て「壊れている」と思いました。わざわざ3台にしたのは、1台落ちても大丈夫にするためです。3つとも同じ1台に載っているなら、その1台が落ちた瞬間に全滅します。台数を増やした意味がありません。

原因は、その少し前に w2 を再起動していたことでした。w2 が戻ってくる前に Deployment を作ったので、そのとき置ける場所は w1 しかありませんでした。 ここまでは当然です。

分からなかったのは、w2 が Ready に戻ったあとも、Pod が1つも移らなかったことです。10分待っても、1時間待っても、w1 に3つのままでした。

Kubernetes のスケジューラは、Pod を「置くとき」に一度だけ働きます。 置いたあと、空いたノードを見つけて均し直すことはしません。

これが分かってから、次の疑問が出ました。「じゃあ、置き場所は運任せなのか」です。

そんなことはありません。置き場所は、こちらから指定できます。 しかも指定のしかたは1つではなく、「Pod 側から言う」「Pod 同士の関係で言う」「ノード側から言う」の3系統があります。今回はそれを全部やります。

この記事は、Pod の回で1度だけ出てきた nodeSelector の続きです。あのときは「存在しない名札を指定したら Pending になった」ところで終わりました。今回はその Pending を起こしている本人(スケジューラ)が、何を見て、何を落としているのかまで踏み込みます。

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

目次

この記事でわかること

  • スケジューラは「置くとき」にしか働かないこと。あとからノードが空いても、動いている Pod は移らない。均したければ人が作り直す(rollout restart)
  • スケジューラは2段階で決めていること。「置けないノードを外す(絞り込み)」→「残りに点を付ける(点数付け)」。Pending の原因はほぼ前半、偏りの原因はほぼ後半
  • nodeName は「指定」ではなく「迂回」であること。スケジューラを飛ばすので、置けなくても Pending にすらならず、Events に何も出ない。使ってはいけない
  • required と preferred の差は「無理なら諦めるか」であること。required は条件に合うノードが無ければ、いつまでも Pending のまま待つ
  • podAntiAffinity の要は topologyKey であること。「何をもって同じ場所とみなすか」を指定していて、ここを間違えると書いたのに散らばらない
  • taint は「ノード側から拒否する」仕組みで、Pod 側の指定とは別系統だということ。両方を同時に満たさないと置かれない
  • NoExecute だけは、いま動いている Pod も追い出すこと。他の2つは「これから置くもの」にしか効かない
  • コントロールプレーンに Pod が載らないのは、そういう仕様だからではなく、taint が1枚貼ってあるだけだということ
  • 優先度を付けると、低い Pod が追い出されること(プリエンプション)。「自分の Pod を優先する」は「誰かの Pod を殺す」と同じ意味
  • これら全部を、普段は使わないほうがいいこと。基本は何も指定しない

この記事でやること

  1. cordon でわざと偏りを作り、kubectl get pod -o wide で「載っている場所」を読む型を身につける
  2. nodeName / nodeSelector / nodeAffinity(required と preferred)の4つを1つずつ書いて、配置がどう変わるか確かめる
  3. podAntiAffinity でレプリカを散らし、台数が足りない required で Pending をわざと起こす
  4. kubectl taint でノードに札を貼り、Pod が来なくなること・tolerations を書いた Pod だけ来ることを確かめ、NoExecute で動いている Pod が追い出されるところまで見る
  5. topologySpreadConstraints と PriorityClass を試し、最後に貼った札とラベルを全部外す

先に知る言葉

この記事で初めて出てくる言葉だけ、その場で短く置きます。 詳しくは 用語集 を見てください。

言葉この記事での意味
スケジューラ(kube-scheduler)置き場所がまだ決まっていない Pod を見つけて、どのノードに置くか決める係。決めるだけで、起動はしない
バインド(bind)スケジューラが決めた結果を、その Pod の nodeName として書き込むこと。これで「置き場所が決まった」状態になる
絞り込み(Filtering)置けないノードを候補から外す段階。ここで全部外れると Pending
点数付け(Scoring)残った候補に点を付けて、一番高いノードを選ぶ段階。ここは Pending にはならず、偏りとして現れる
-o widekubectl get の出力に列を増やすオプション。Pod ならIPと、載っているノード名が出る
cordon / uncordonノードを「新しく置くのは禁止」にする / 戻す。すでに動いている Pod は追い出さない
taint(テイント)ノードに貼る「ここには置くな」という札。ノード側から拒否する
toleration(トレラント)その札を「許容する」という Pod 側の申告。札があっても、これがあれば置かれる
topologyKey「何が同じなら、同じ場所とみなすか」を決めるノードのラベル名。kubernetes.io/hostname なら「同じサーバー」
プリエンプション(preemption)優先度の高い Pod を置くために、低い Pod を止めて場所を空けること
エビクション(eviction)Pod を追い出すこと。スケジューラがやる場合(プリエンプション)と、ノード側が資源不足でやる場合がある
PriorityClass優先度に名前と数値を付けた部品。Pod からは名前で参照する

準備:3台のクラスタと、実験用の Deployment

まずノードを確認します。

bash
$ kubectl get nodes
NAME   STATUS   ROLES           AGE   VERSION
cp1    Ready    control-plane   14d   v1.33.1
w1     Ready    <none>          14d   v1.33.1
w2     Ready    <none>          14d   v1.33.1

この記事では、この3台の名前(cp1 / w1 / w2)で書きます。 自分の環境の名前に読み替えてください。

[スクリーンショット: 01_get-nodes.png] VM の中で kubectl get nodes を実行し、3台とも Ready になっている画面を撮ってください。

minikube 1台でやる場合の読み替え

1台しかなくても、この記事の8割は動きます。 ただし次の3点だけ違います。

内容3台のクラスタminikube 1台
ノード名cp1 / w1 / w2minikube だけ
散らばるところ見える見えない。代わりに Pending になる(それはそれで学べます)
コントロールプレーンの taint貼ってあるminikube が外しているので見えない

複数台を手軽に用意したいだけなら、minikube でも台数を増やせます。

bash
$ minikube start --nodes=3

ノード名は minikube / minikube-m02 / minikube-m03 になります。ただし minikube は control-plane の taint を外してしまうので、taint の節だけは自分で貼って試すことになります(その手順もこの記事に書きます)。

実験用の Deployment を1つ作る

以降ずっと使う Deployment を作ります。中身は何でもいいので、軽い nginx にします。

bash
$ kubectl create deployment web --image=nginx --replicas=3
$ kubectl get pod -o wide
NAME                   READY   STATUS    RESTARTS   AGE   IP           NODE   NOMINATED NODE   READINESS GATES
web-5d8c9f7b4d-2xk9p   1/1     Running   0          20s   10.244.1.7   w1     <none>           <none>
web-5d8c9f7b4d-8mtqz   1/1     Running   0          20s   10.244.2.5   w2     <none>           <none>
web-5d8c9f7b4d-l4vnc   1/1     Running   0          20s   10.244.1.8   w1     <none>           <none>

-o wide を付けないと NODE 列が出ません。 この記事では毎回付けます。「どこに載っているか」を見ないと、この記事は何も確認できないからです。

cp1 が1つも出てこないことに気付いたと思います。理由は後半の taint の節でやります。

冒頭の「全部同じノード」を、わざと再現する

偶然を待つ必要はありません。cordon を使えば確実に再現できます。

bash
$ kubectl cordon w2
node/w2 cordoned
bash
$ kubectl get nodes
NAME   STATUS                     ROLES           AGE   VERSION
cp1    Ready                      control-plane   14d   v1.33.1
w1     Ready                      <none>          14d   v1.33.1
w2     Ready,SchedulingDisabled   <none>          14d   v1.33.1

SchedulingDisabled が付きました。 これは「新しく置くのは禁止」という意味で、いま w2 で動いている Pod は追い出されません。 ノードを止める前の準備によく使います。

この状態で作り直します。

bash
$ kubectl rollout restart deployment web
$ kubectl get pod -o wide
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-6c9f4d8b7f-4hkzn   1/1     Running   0          25s   10.244.1.11   w1
web-6c9f4d8b7f-9wq2t   1/1     Running   0          25s   10.244.1.12   w1
web-6c9f4d8b7f-hd7cx   1/1     Running   0          25s   10.244.1.13   w1

3つとも w1 になりました。 冒頭と同じ状態です。禁止を解きます。

bash
$ kubectl uncordon w2
$ kubectl get pod -o wide
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-6c9f4d8b7f-4hkzn   1/1     Running   0          2m    10.244.1.11   w1
web-6c9f4d8b7f-9wq2t   1/1     Running   0          2m    10.244.1.12   w1
web-6c9f4d8b7f-hd7cx   1/1     Running   0          2m    10.244.1.13   w1

1つも動きません。 10分待っても同じです。

w2 が空いたことを、誰も見ていません。 スケジューラの仕事は「まだ置き場所が決まっていない Pod」を探すことだけで、すでに決まっている Pod は視界に入っていません。

均したいなら、人が作り直すしかありません。

bash
$ kubectl rollout restart deployment web
$ kubectl get pod -o wide
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-7d5b8c6f94-6nptl   1/1     Running   0          30s   10.244.2.9    w2
web-7d5b8c6f94-jc8rd   1/1     Running   0          30s   10.244.1.15   w1
web-7d5b8c6f94-x9v2m   1/1     Running   0          30s   10.244.2.10   w2

散りました。rollout restart は Pod を作り直すので、そのタイミングでスケジューラがもう一度考えます。

これは「ノードを1台メンテしたあと、必ずやること」です。 メンテ明けに uncordon しただけで安心すると、戻したはずのノードが空のままになります。kubectl get pod -o wide -A で偏りを確認する癖をつけてください。

スケジューラは、2段階で決めている

ここからが本題です。スケジューラは1回で決めているのではなく、はっきり2段階に分かれています。

段階呼び方やること結果失敗すると
1. 絞り込みFiltering(旧: Predicates)置けないノードを候補から外す。条件は「はい / いいえ」だけ候補ノードの一覧候補が0件 → Pending。FailedScheduling が Events に出る
2. 点数付けScoring(旧: Priorities)残った候補に点を付ける。0〜100点一番高い1台失敗しない。ただ「思ったところに載らない」だけ

この2段階を分けて覚えると、トラブルの切り分けが一気に楽になります。

Pending で止まっているなら、原因は必ず1段階目です。 動いてはいるが場所が気に入らないなら、原因は2段階目です。

1段階目(絞り込み)で外される代表的な理由

理由具体例
資源が足りないPod の requests の合計が、そのノードの空きを超える(前回の話)
nodeSelector / nodeAffinity(required)に合わない指定したラベルがノードに無い
taint があって toleration が無い後半でやります
ポートが埋まっているhostPort を使っていて、そのノードで既に使われている
ボリュームが別ノードにあるローカルの PV は、その PV があるノードにしか置けない(ストレージの回)
ノードが受け付けない状態NotReady、SchedulingDisabled(さっきの cordon)

2段階目(点数付け)で使われる代表的な観点

観点高い点が付くノード
空きの多さ既定は「空きが多いほうが高得点」。だから普通は自然に散らばる
イメージを持っているかそのコンテナイメージを既にダウンロード済みのノード(起動が速いため)
preferred の希望nodeAffinity / podAffinity / podAntiAffinity の「できれば」の指定
散らばり具合topologySpreadConstraints(後述)

「点数付けは失敗しない」が大事です。preferred で書いた希望が1つも満たされなくても、エラーは出ません。黙って別のノードに置かれます。

決まったあとの流れは「Kubernetes を入れるか」の回でやったとおりです。スケジューラは kubelet に命令せず、API Server に「w1 に置くことにした」と書き込むだけです。それを見た w1 の kubelet が起動します。

置き場所を Pod 側から指定する4つの方法

Pod 側から言う方法は4つあります。上から順に、荒っぽくて危険 → 細かくて安全の並びです。

#書き方意味スケジューラを通るか使ってよいか
1nodeNameこのノードに置け(名指し)通らない(迂回)❌ 使わない
2nodeSelectorこの名札のノードにだけ置け通る○ 単純な条件なら
3nodeAffinity の requiredこの条件のノードにだけ置け通る◎ 条件が複雑ならこちら
4nodeAffinity の preferredできればこの条件のノードに通る◎ まずこれを検討する

順にやります。

1. nodeName — スケジューラを迂回する(使わない)

nodeName は、Pod の spec にノード名を直接書くやり方です。

pod-nodename.yaml を作ります。

bash
$ nano pod-nodename.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pin-w2
spec:
  nodeName: w2
  containers:
  - name: nginx
    image: nginx:1.27-alpine
bash
$ kubectl apply -f pod-nodename.yaml
$ kubectl get pod pin-w2 -o wide
NAME     READY   STATUS    RESTARTS   AGE   IP           NODE
pin-w2   1/1     Running   0          8s    10.244.2.14  w2

ちゃんと w2 に載りました。動きます。 だからこそ危険です。

何が起きているかを思い出してください。スケジューラの仕事は、決めた結果を nodeName に書き込むことでした。それを自分で先に書いてしまったので、この Pod は「もう置き場所が決まっているもの」として扱われます。スケジューラの視界に、最初から入りません。

存在しないノード名を書いて確かめます。

bash
$ sed 's/name: pin-w2/name: pin-ghost/; s/nodeName: w2/nodeName: w9/' pod-nodename.yaml > pod-ghost.yaml
$ kubectl apply -f pod-ghost.yaml
$ kubectl get pod pin-ghost -o wide
NAME        READY   STATUS    RESTARTS   AGE   IP       NODE   NOMINATED NODE
pin-ghost   0/1     Pending   0          60s   <none>   w9     <none>

ここを見てください。NODE 列に w9 と書いてあります。 存在しないノードなのに、です。

bash
$ kubectl describe pod pin-ghost | tail -5
Events:  <none>

Events が空です。 Pod の回でやった FailedScheduling は出ません。スケジューラが関与していないので、文句を言う人が誰も居ないからです。

nodeName の Pending は、理由がどこにも出ません。 「Pending なのに Events が空」なら、まず nodeName を疑ってください。

これが nodeName を使ってはいけない理由です。動くときは動きますが、動かないときに何も分からない。しかも資源が足りなくても、taint があっても、無視して置きに行きます。

bash
$ kubectl delete pod pin-w2 pin-ghost
$ rm pod-nodename.yaml pod-ghost.yaml

2. nodeSelector — 名札で単純に選ぶ

まずノードに名札(ラベル)を貼ります。ノードは最初から名札を持っています。

bash
$ kubectl get nodes --show-labels

長いので、1台だけ整形して見ます。

bash
$ kubectl get node w1 -o jsonpath='{.metadata.labels}' | tr ',' '\n'
{"beta.kubernetes.io/arch":"amd64"
"beta.kubernetes.io/os":"linux"
"kubernetes.io/arch":"amd64"
"kubernetes.io/hostname":"w1"
"kubernetes.io/os":"linux"}

kubernetes.io/hostname に注目してください。 これは全ノードが必ず持っている、値がノードごとに違うラベルです。後で topologyKey の話に効いてきます。

自分で1枚貼ります。

bash
$ kubectl label node w1 disktype=ssd
$ kubectl label node w2 disktype=hdd
node/w1 labeled
node/w2 labeled

貼れたことを確認します。

bash
$ kubectl get nodes -L disktype
NAME   STATUS   ROLES           AGE   VERSION   DISKTYPE
cp1    Ready    control-plane   14d   v1.33.1
w1     Ready    <none>          14d   v1.33.1   ssd
w2     Ready    <none>          14d   v1.33.1   hdd

-L <ラベル名> は「そのラベルを列として出す」オプションです。--show-labels より読みやすいので、この記事では以降こちらを使います。

pod-selector.yaml を作ります。

bash
$ nano pod-selector.yaml
apiVersion: v1
kind: Pod
metadata:
  name: on-ssd
spec:
  nodeSelector:
    disktype: ssd
  containers:
  - name: nginx
    image: nginx:1.27-alpine
bash
$ kubectl apply -f pod-selector.yaml
$ kubectl get pod on-ssd -o wide
NAME     READY   STATUS    RESTARTS   AGE   IP            NODE
on-ssd   1/1     Running   0          6s    10.244.1.21   w1

w1 に載りました。 今度はスケジューラを通っているので、外すと理由が出ます。ラベルを剥がしてみます。

bash
$ kubectl label node w1 disktype-
$ kubectl delete pod on-ssd
$ kubectl apply -f pod-selector.yaml
$ kubectl describe pod on-ssd | grep -A4 Events
Events:
  Type     Reason            Age   From               Message
  ----     ------            ----  ----               -------
  Warning  FailedScheduling  12s   default-scheduler  0/3 nodes are available: 1 node(s) had untolerated taint {node-role.kubernetes.io/control-plane: }, 2 node(s) didn't match Pod's node affinity/selector.

この1行が読めるようになるのが、この記事の目的の半分です。

部分意味
0/3 nodes are available3台のうち0台しか使えなかった(1段階目で全滅)
1 node(s) had untolerated taint {node-role.kubernetes.io/control-plane: }1台(cp1)は taint で外れた
2 node(s) didn't match Pod's node affinity/selector2台(w1/w2)は名札が合わなくて外れた

ラベルを剥がしたのは w1 だけなのに、w2 も「合わない」に数えられています。 w2 は disktype=hdd を持っていますが、求めているのは ssd だからです。「ラベルが無い」も「ラベルの値が違う」も、同じ扱いです。

なお、ラベルを消すのは disktype-(末尾がハイフン)です。 disktype= と書くと「空文字を値にする」という意味になり、消えません。ここは何度も間違えます。

貼り直して片付けます。

bash
$ kubectl label node w1 disktype=ssd
$ kubectl delete pod on-ssd

数秒待てば on-ssd は勝手に Running になったはずですが、次に進むために消しました。 Pending の Pod は、条件が満たされた瞬間に置かれます。 消えたわけではなく、ずっと待っています。

3. nodeAffinity の required — 条件を細かく書く

nodeSelector は「このキーがこの値」しか書けません。 「ssd か nvme のどちらか」は書けません。それを書けるようにしたのが nodeAffinity です。

pod-affinity-required.yaml を作ります。

bash
$ nano pod-affinity-required.yaml
apiVersion: v1
kind: Pod
metadata:
  name: need-fast-disk
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: disktype
            operator: In
            values:
            - ssd
            - nvme
  containers:
  - name: nginx
    image: nginx:1.27-alpine

この長いキー名は暗記しません。 分解すると意味だけ残ります。

部分意味
requiredDuringScheduling置くときには必須
IgnoredDuringExecution動き出したあとは無視する(条件から外れても追い出さない)

IgnoredDuringExecution は「置いたあとにノードのラベルを変えても、Pod は動き続ける」という意味です。 さっき disktype を剥がしたのに、動いている Pod が消えなかったのはこれです。

operator は次が使えます。nodeSelector にできなかったことが、ここで全部できます。

operator意味
Inどれかに一致(values に列挙)
NotInどれにも一致しない
Existsキーがあればよい(値は問わない。values は書かない)
DoesNotExistキーが無いこと
Gt / Lt数値として大きい / 小さい
bash
$ kubectl apply -f pod-affinity-required.yaml
$ kubectl get pod need-fast-disk -o wide
NAME             READY   STATUS    RESTARTS   AGE   IP            NODE
need-fast-disk   1/1     Running   0          7s    10.244.1.23   w1

w1 にしか置けないので、w1 に載ります。 w2 は hdd なので候補から外れています。

4. nodeAffinity の preferred — できればそこに

「無いなら諦めて別のところでいい」が preferred です。現場で使うのはほとんどこちらです。

pod-affinity-preferred.yaml を作ります。

bash
$ nano pod-affinity-preferred.yaml
apiVersion: v1
kind: Pod
metadata:
  name: prefer-fast-disk
spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 80
        preference:
          matchExpressions:
          - key: disktype
            operator: In
            values:
            - nvme
  containers:
  - name: nginx
    image: nginx:1.27-alpine

preferred は配列(- weight: で始まる項目の並び)です。 required の nodeSelectorTerms とは形が違います。containers: は spec: の直下なので、インデントは2つ分です。

nvme のノードは1台もありません。 required なら Pending になるところです。

bash
$ kubectl apply -f pod-affinity-preferred.yaml
$ kubectl get pod prefer-fast-disk -o wide
NAME               READY   STATUS    RESTARTS   AGE   IP           NODE
prefer-fast-disk   1/1     Running   0          6s    10.244.2.18  w2

w2 に載りました。 希望は1つも満たされていませんが、エラーも警告も出ません。

書き方条件に合うノードが無いとき
requiredPending のまま待ち続ける
preferred黙って別のノードに置く

preferred の weight は 1〜100 で、満たしたときに加算される点数です。複数書けます。 「A なら 80点、B なら 20点」と書くと、両方満たすノードは100点になります。

weight は「絶対に」ではありません。 空きの多さなど、他の観点の点数と足し算されるだけです。「100 にしたのに希望どおりに載らない」は、バグではなく仕様です。

bash
$ kubectl delete pod need-fast-disk prefer-fast-disk

[スクリーンショット: 02_pod-o-wide-nodes.png] kubectl get pod -o wide の出力で、Pod ごとに NODE 列が違っている画面を撮ってください。

Pod 同士の関係で決める

ここまでは「ノードの性質」で選びました。現場で本当に欲しいのは、そこではありません。

欲しいのは「同じアプリのレプリカを、同じサーバーに固めないでほしい」です。 これはノードの性質ではなく、「そこに何が既に居るか」の話です。

これをやるのが podAffinity / podAntiAffinity です。

podAntiAffinity — 同じノードに固めない

web-spread.yaml を作ります。Deployment なので、さっきの web はいったん消します。

bash
$ kubectl delete deployment web
$ nano web-spread.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchLabels:
                  app: web
              topologyKey: kubernetes.io/hostname
      containers:
      - name: nginx
        image: nginx:1.27-alpine

読み方は「app: web が既に居る場所を、できれば避けろ」です。

labelSelector に書くのは、自分自身のラベルです。ここが最初は気持ち悪いところでした。「自分と同じ名札の Pod から離れろ」と言っているので、自分のラベルを書くのが正しいです。

ここを app: web ではなく別の名前にすると、何も起きません。エラーも出ません。 一致する Pod が1つも無いので、「避ける相手が居ない」だけになります。

bash
$ kubectl apply -f web-spread.yaml
$ kubectl get pod -o wide -l app=web
NAME                  READY   STATUS    RESTARTS   AGE   IP            NODE
web-84c7d9f6b-4tznq   1/1     Running   0          15s   10.244.1.28   w1
web-84c7d9f6b-9dkxl   1/1     Running   0          15s   10.244.2.21   w2
web-84c7d9f6b-pm5w7   1/1     Running   0          15s   10.244.1.29   w1

w1 に2つ、w2 に1つ。 置ける場所が2台しかないので、3つ目はどちらかに重なります。 preferred なので、重なることを受け入れて置きました。

さっきの cordon の実験をもう一度やると、差が分かります。

bash
$ kubectl cordon w2
$ kubectl rollout restart deployment web
$ kubectl get pod -o wide -l app=web
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-5f9b7c8d64-8jzqp   1/1     Running   0          20s   10.244.1.31   w1
web-5f9b7c8d64-mn4rt   1/1     Running   0          20s   10.244.1.32   w1
web-5f9b7c8d64-w6bxk   1/1     Running   0          20s   10.244.1.33   w1

preferred なので、全部 w1 に載ります。 これが preferred の性格です。「散らせるなら散らす。無理なら諦めて動かす」。

bash
$ kubectl uncordon w2

topologyKey の意味 — 何を「同じ場所」とみなすか

topologyKey は、この仕組みの中で一番大事で、一番間違えやすいところです。

topologyKey: kubernetes.io/hostname と書きました。これは「そのラベルの値が同じノードどうしを、同じ場所とみなす」という意味です。

topologyKey に指定するラベル「同じ場所」の単位避けられる障害
kubernetes.io/hostname同じサーバーサーバー1台の故障
topology.kubernetes.io/zone同じデータセンター(ゾーン)建物ごとの停電
topology.kubernetes.io/region同じ地域地域全体の障害
自分で貼ったラベル(例: rack=r1)同じラックラックの電源やスイッチ

topologyKey に書くのは「ノードのラベル名」です。ノード名ではありません。 topologyKey: w1 は間違いです。

自分で単位を作れることを確かめます。w1 と w2 を「同じラック」にしてみます。

bash
$ kubectl label node w1 rack=r1
$ kubectl label node w2 rack=r1
$ kubectl get nodes -L rack
NAME   STATUS   ROLES           AGE   VERSION   RACK
cp1    Ready    control-plane   14d   v1.33.1
w1     Ready    <none>          14d   v1.33.1   r1
w2     Ready    <none>          14d   v1.33.1   r1

この状態で topologyKey: rack にすると、スケジューラから見て w1 と w2 は「同じ場所」になります。「別のラックに置け」と言われても、別のラックが存在しないので、散らしようがありません。

これが topologyKey の怖いところです。 同じ YAML でも、ノードのラベルの貼り方1つで意味が変わります。

required にして、Pending をわざと起こす

preferred を required に変えます。「重なるくらいなら置くな」という意味になります。

bash
$ nano web-spread-required.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchLabels:
                app: web
            topologyKey: kubernetes.io/hostname
      containers:
      - name: nginx
        image: nginx:1.27-alpine

required は preferred と書き方が違います。 preferred は weight と podAffinityTerm で1段深くなりますが、required は labelSelector と topologyKey を直接並べます。 ここは毎回間違えるところなので、kubectl explain で確かめる癖をつけてください。

bash
$ kubectl explain deployment.spec.template.spec.affinity.podAntiAffinity

適用します。

bash
$ kubectl apply -f web-spread-required.yaml
$ kubectl get pod -o wide -l app=web
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-6b4f8d9c75-hq2vn   1/1     Running   0          25s   10.244.1.35   w1
web-6b4f8d9c75-r8ktd   1/1     Running   0          25s   10.244.2.24   w2
web-6b4f8d9c75-zx7mp   0/1     Pending   0          25s   <none>        <none>

3つ目が Pending になりました。狙いどおりです。 理由を読みます。

bash
$ kubectl describe pod -l app=web | grep -A4 "Events" | tail -6
  Warning  FailedScheduling  30s   default-scheduler  0/3 nodes are available: 1 node(s) had untolerated taint {node-role.kubernetes.io/control-plane: }, 2 node(s) didn't match pod anti-affinity rules.

didn't match pod anti-affinity rules。 w1 と w2 には既に app: web が居るので、両方とも「置けないノード」になりました。置ける場所が0件なので Pending です。

required の podAntiAffinity は、「レプリカ数 ≦ ノード数」でないと必ず余ります。 1台しかないクラスタなら、レプリカ2で即 Pending です。minikube 1台の人はここで確かめられます。

これは事故ではなく、そう書いたからです。「重なるくらいなら動かないほうがマシ」という宣言をしたので、そのとおりに動いています。データベースのように「絶対に同居させたくない」ものでは、これが正解になります。

preferred に戻します。

bash
$ kubectl apply -f web-spread.yaml
$ kubectl get pod -o wide -l app=web

podAffinity — 逆に、近くに置く

podAntiAffinity の反対が podAffinity です。「あれと同じ場所に置け」という指定です。

用途はほぼ1つ、「通信が多いもの同士を近づける」です。キャッシュとアプリを同じサーバーに置けば、ネットワークを1本またがない分だけ速くなります。

cache-near.yaml を作ります。

bash
$ nano cache-near.yaml
apiVersion: v1
kind: Pod
metadata:
  name: cache-near-web
  labels:
    app: cache
spec:
  affinity:
    podAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchLabels:
            app: web
        topologyKey: kubernetes.io/hostname
  containers:
  - name: redis
    image: redis:7-alpine
bash
$ kubectl apply -f cache-near.yaml
$ kubectl get pod -o wide
NAME                  READY   STATUS    RESTARTS   AGE   IP            NODE
cache-near-web        1/1     Running   0          10s   10.244.1.41   w1
web-84c7d9f6b-4tznq   1/1     Running   0          6m    10.244.1.28   w1
web-84c7d9f6b-9dkxl   1/1     Running   0          6m    10.244.2.21   w2
web-84c7d9f6b-pm5w7   1/1     Running   0          6m    10.244.1.29   w1

web が居るノードに載りました。

podAffinity の required は、依存の向きを作ります。 web が1つも居ないところに cache を先に置こうとすると、永久に Pending です。起動順に暗黙の依存ができるので、required で書くのは慎重にしてください。私は preferred 以外で使ったことがありません。

bash
$ kubectl delete pod cache-near-web

taints と tolerations — ノード側から拒否する

ここまでは全部 Pod 側からの指定でした。逆向きの仕組みがあります。

nodeAffinity は「Pod が、ノードを選ぶ」。 taint は「ノードが、Pod を断る」。

なぜ両方要るのか。 「このノードは GPU 専用にしたい」を Pod 側だけでやろうとすると、クラスタ中の全 Pod に「GPU ノードには行くな」と書いて回ることになります。1つでも書き忘れたら侵入されます。

taint なら、ノードに1枚札を貼るだけで、全部の Pod に効きます。 既定が「拒否」になるのが決定的な違いです。

kubectl taint で札を貼る

bash
$ kubectl taint nodes w2 maintenance=true:NoSchedule
node/w2 tainted

書式は キー=値:効果 です。

maintenance = true : NoSchedule
    ↑        ↑        ↑
   キー      値       効果

貼れたか確認します。

bash
$ kubectl describe node w2 | grep -i taints
Taints:             maintenance=true:NoSchedule

この状態で、w2 に Pod が来ないことを確かめます。

bash
$ kubectl rollout restart deployment web
$ kubectl get pod -o wide -l app=web
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-79d6c8b5f4-2qzlm   1/1     Running   0          20s   10.244.1.44   w1
web-79d6c8b5f4-k7ntc   1/1     Running   0          20s   10.244.1.45   w1
web-79d6c8b5f4-vp9wd   1/1     Running   0          20s   10.244.1.46   w1

3つとも w1 です。 podAntiAffinity(preferred)で「散らせ」と書いてあるのに、w2 には行きません。

taint は1段階目(絞り込み)で効きます。 preferred は2段階目(点数付け)です。1段階目で外されたノードは、点数を付ける対象にすら残っていません。

tolerations を書いた Pod だけ来る

札を許容する Pod を作ります。

bash
$ nano pod-tolerate.yaml
apiVersion: v1
kind: Pod
metadata:
  name: maintenance-ok
spec:
  tolerations:
  - key: maintenance
    operator: Equal
    value: "true"
    effect: NoSchedule
  nodeSelector:
    disktype: hdd
  containers:
  - name: nginx
    image: nginx:1.27-alpine

nodeSelector: disktype: hdd を足したのは、確実に w2 へ行かせるためです。toleration は「行ってもよい」であって「行け」ではありません。 ここは初めて読むと必ず誤解します。

toleration は許可証であって、指示書ではありません。 札を無視できるようになるだけで、そのノードに行きたくなるわけではありません。

bash
$ kubectl apply -f pod-tolerate.yaml
$ kubectl get pod maintenance-ok -o wide
NAME             READY   STATUS    RESTARTS   AGE   IP            NODE
maintenance-ok   1/1     Running   0          8s    10.244.2.31   w2

w2 に載りました。 札があるノードに、許可証を持った Pod だけが入れています。

value を問わず「キーがあれば許す」と書くこともできます。

  tolerations:
  - key: maintenance
    operator: Exists
    effect: NoSchedule

key も省略して operator: Exists だけにすると、「あらゆる taint を許す」という意味になります。これを書くと、コントロールプレーンにも故障中のノードにも置かれます。書かないでください。

3つの効果(effect)の違い

同じ札でも、効果が3種類あります。ここが山場です。

effectこれから置く Podいま動いている Pod
NoSchedule置かないそのまま動き続ける
PreferNoScheduleできれば置かない(他に無ければ置く)そのまま動き続ける
NoExecute置かない追い出す

NoExecute だけが、既に動いているものに手を出します。 実際にやります。

いま w2 には maintenance-ok が動いています。NoExecute の札を追加します。

bash
$ kubectl get pod -o wide -l app=web
$ kubectl get pod maintenance-ok -o wide
$ kubectl taint nodes w2 evacuate=now:NoExecute
node/w2 tainted

すぐに見ます。

bash
$ kubectl get pod -o wide -w
NAME             READY   STATUS        RESTARTS   AGE   IP            NODE
maintenance-ok   1/1     Terminating   0          3m    10.244.2.31   w2
maintenance-ok   0/1     Terminating   0          3m    10.244.2.31   w2

Terminating になりました。 Ctrl+C で -w(監視)を抜けます。

bash
$ kubectl get pod -o wide
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-79d6c8b5f4-2qzlm   1/1     Running   0          5m    10.244.1.44   w1
web-79d6c8b5f4-k7ntc   1/1     Running   0          5m    10.244.1.45   w1
web-79d6c8b5f4-vp9wd   1/1     Running   0          5m    10.244.1.46   w1

maintenance-ok は消えました。 戻ってきません。単体の Pod には面倒を見る係が居ないからです(Pod の回でやったとおりです)。Deployment 配下なら、別のノードで作り直されます。

NoExecute は「置かせない」ではなく「今すぐ出て行け」です。 運用中のノードにこれを打つと、そのノードのアプリが全部止まります。 落ち着いて退避させたいなら、次のどちらかを使ってください。

やりたいこと使うもの
これ以上増やしたくないだけkubectl cordon <ノード>
順番に、安全に退避させたいkubectl drain <ノード> --ignore-daemonsets

drain は内部で cordon してから、1つずつ Pod を退避させます。 NoExecute の taint は一斉に追い出すので、同時に全部落ちます。

NoExecute には猶予も付けられます。

  tolerations:
  - key: evacuate
    operator: Exists
    effect: NoExecute
    tolerationSeconds: 300

「この札が付いても、300秒は残ってよい」という意味です。実は、これは自分で書かなくても全 Pod に自動で付いています。 確かめます。

bash
$ kubectl get pod -l app=web -o jsonpath='{.items[0].spec.tolerations}' | tr '}' '\n'
[{"effect":"NoExecute","key":"node.kubernetes.io/not-ready","operator":"Exists","tolerationSeconds":300
,{"effect":"NoExecute","key":"node.kubernetes.io/unreachable","operator":"Exists","tolerationSeconds":300
]

書いた覚えのない toleration が2つ入っています。 意味はこうです。

「ノードが NotReady になっても、届かなくなっても、300秒は待つ」。

本線の 3台クラスタの回で「1台落としても Pod が移った」とき、移るまでに数分かかったのは、これが理由です。すぐ移さないのは、一時的なネットワークの切れで全部作り直すのを避けるためです。

札を1枚剥がします。

bash
$ kubectl taint nodes w2 evacuate=now:NoExecute-
node/w2 untainted

剥がすときは末尾に - を付けます。 ラベルと同じ規則です。kubectl taint nodes w2 evacuate- のようにキーだけでも剥がせます。

コントロールプレーンの taint を確かめる

cp1 に Pod が1つも載らなかった理由を、いま説明できます。

bash
$ kubectl describe node cp1 | grep -i taints
Taints:             node-role.kubernetes.io/control-plane:NoSchedule

札が1枚貼ってあるだけでした。kubeadm が自動で貼ります。

誤解実際
コントロールプレーンには、仕様上 Pod を置けない置ける。札を剥がせば普通に置かれる
cp1 は Kubernetes の管理用で、Pod は動いていない動いている。 kube-apiserver や etcd 自体が Pod

確かめます。

bash
$ kubectl get pods -n kube-system -o wide --field-selector spec.nodeName=cp1
NAME                          READY   STATUS    RESTARTS   AGE   IP               NODE
etcd-cp1                      1/1     Running   3          14d   192.168.226.50   cp1
kube-apiserver-cp1            1/1     Running   3          14d   192.168.226.50   cp1
kube-controller-manager-cp1   1/1     Running   3          14d   192.168.226.50   cp1
kube-scheduler-cp1            1/1     Running   3          14d   192.168.226.50   cp1

動いています。 これらはこの taint を許容する toleration を持っているので置かれています。「置けない場所」ではなく、「許可証を持ったものだけが置ける場所」です。

なぜ普通の Pod を置かせないのか。 クラスタの頭脳が動いているサーバーで、アプリがメモリを食い尽くすと、クラスタ全体の操作ができなくなるからです。壊れる場所と、直す人を分けています。

minikube では、この taint が最初から外してあります。 1台しか無いのに置けなかったら何も動かないからです。minikube で試したい人は、自分で貼って剥がしてください。

bash
$ kubectl taint nodes minikube node-role.kubernetes.io/control-plane:NoSchedule
$ kubectl taint nodes minikube node-role.kubernetes.io/control-plane:NoSchedule-

貼ったままにすると、その minikube では何も動かせなくなります。必ず剥がしてください。

[スクリーンショット: 03_describe-node-taints.png] kubectl describe node cp1 | grep -i taints で NoSchedule の札が表示されている画面を撮ってください。

topologySpreadConstraints — 均等に散らす

podAntiAffinity には、はっきりした弱点があります。

podAntiAffinity は「重なるか、重ならないか」しか言えません。 「まあまあ均等に」が書けません。

preferred は「できれば避ける」なので、どこまで偏ってよいのかを指定できません。 required は「1台1つまで」なので、レプリカ数がノード数を超えた瞬間に Pending になります。その中間が無いわけです。

それを埋めるのが topologySpreadConstraints です。「偏りの許容量」を数字で書けます。

bash
$ kubectl delete deployment web
$ nano web-spread-topo.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 4
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      topologySpreadConstraints:
      - maxSkew: 1
        topologyKey: kubernetes.io/hostname
        whenUnsatisfiable: DoNotSchedule
        labelSelector:
          matchLabels:
            app: web
      containers:
      - name: nginx
        image: nginx:1.27-alpine

maxSkew が主役です。

skew(スキュー)=「一番多い場所の数」−「一番少ない場所の数」。 maxSkew: 1 は「その差を1以下に保て」という意味です。

配置skewmaxSkew: 1 で許されるか
w1に2つ / w2に2つ0○
w1に3つ / w2に2つ1○
w1に4つ / w2に2つ2✕
bash
$ kubectl apply -f web-spread-topo.yaml
$ kubectl get pod -o wide -l app=web
NAME                  READY   STATUS    RESTARTS   AGE   IP            NODE
web-9c7f5d84b-6xmhq   1/1     Running   0          18s   10.244.1.51   w1
web-9c7f5d84b-b2ktn   1/1     Running   0          18s   10.244.2.36   w2
web-9c7f5d84b-nq8vz   1/1     Running   0          18s   10.244.1.52   w1
web-9c7f5d84b-tw4pl   1/1     Running   0          18s   10.244.2.37   w2

2つずつ、きれいに分かれました。 podAntiAffinity の required ではレプリカ3で Pending になったのに、こちらはレプリカ4でも全部置けています。

whenUnsatisfiable が、required と preferred に相当します。

値意味
DoNotSchedule守れないなら置かない(required 相当)
ScheduleAnyway守れなくても置く。ただし点数付けでは偏りを嫌う(preferred 相当)

DoNotSchedule の限界も見ておきます。w2 を止めて、レプリカを増やします。

bash
$ kubectl cordon w2
$ kubectl scale deployment web --replicas=6
$ kubectl get pod -o wide -l app=web
NAME                  READY   STATUS    RESTARTS   AGE   IP            NODE
web-9c7f5d84b-6xmhq   1/1     Running   0          3m    10.244.1.51   w1
web-9c7f5d84b-b2ktn   1/1     Running   0          3m    10.244.2.36   w2
web-9c7f5d84b-nq8vz   1/1     Running   0          3m    10.244.1.52   w1
web-9c7f5d84b-tw4pl   1/1     Running   0          3m    10.244.2.37   w2
web-9c7f5d84b-hj3rd   0/1     Pending   0          20s   <none>        <none>
web-9c7f5d84b-s9fkw   0/1     Pending   0          20s   <none>        <none>

増やした2つが Pending です。 w1 に足すと 4対2 で skew が 2 になり、maxSkew: 1 を超えるからです。

DoNotSchedule は「ノードが1台落ちているときに、レプリカを増やせない」という性質を持ちます。可用性のために書いた設定が、可用性を下げる場面です。迷ったら ScheduleAnyway から始めてください。

bash
$ kubectl uncordon w2
$ kubectl scale deployment web --replicas=3

topologySpreadConstraints は、実は既定でも弱く効いています。 クラスタ全体の既定として maxSkew: 3 の ScheduleAnyway が入っているので、何も書かなくてもある程度は散ります。 ただし「3個までの偏りは許す」ので、小さなクラスタでは全部同じノード、が普通に起きます。 冒頭の状況はこれでも説明できます。

優先度とプリエンプション — 誰かを追い出して場所を作る

ここまでは「空いている場所をどう選ぶか」でした。空いていないときの話が残っています。

普通は Pending で待ちます。 ですが、「これは待たせたくない」というものがあります。監視や、ログ収集や、決済です。

そのために PriorityClass があります。

bash
$ nano priority.yaml
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: low-priority
value: 100
globalDefault: false
description: "止まっても困らない実験用"
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: high-priority
value: 100000
globalDefault: false
description: "止めたくないもの"

PriorityClass は名前空間に属しません。クラスタ全体で1つです。

bash
$ kubectl apply -f priority.yaml
$ kubectl get priorityclass
NAME                      VALUE        GLOBAL-DEFAULT   AGE
high-priority             100000       false            5s
low-priority              100          false            5s
system-cluster-critical   2000000000   false            14d
system-node-critical      2000001000   false            14d

最初から2つ入っています。 system-node-critical はkubelet や CNI など、これが止まるとノードが機能しないものに付いています。数字がけた違いなのは、絶対に追い出されないようにするためです。

場所を埋める

まず w1 を埋めます。空きを確認します。

bash
$ kubectl describe node w1 | grep -A6 "Allocated resources"
Allocated resources:
  Resource           Requests     Limits
  --------           --------     ------
  cpu                350m (17%)   0 (0%)
  memory             140Mi (3%)   340Mi (8%)

このノードは 2 CPU(2000m)で、350m 使用済みです。空きは 1650m 前後です。

数字は環境ごとに違います。 以下の 900m は、自分のノードの空きの半分弱に読み替えてください。大きすぎると最初から置けず、小さすぎると埋まりません。

filler.yaml を作ります。nodeSelector で w1 に固定します。

bash
$ kubectl label node w1 lab=preempt
$ nano filler.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: filler
spec:
  replicas: 2
  selector:
    matchLabels:
      app: filler
  template:
    metadata:
      labels:
        app: filler
    spec:
      priorityClassName: low-priority
      nodeSelector:
        lab: preempt
      containers:
      - name: pause
        image: nginx:1.27-alpine
        resources:
          requests:
            cpu: "900m"
bash
$ kubectl apply -f filler.yaml
$ kubectl get pod -o wide -l app=filler
NAME                     READY   STATUS    RESTARTS   AGE   IP            NODE
filler-6b8d9f7c5-4xmnp   1/1     Running   0          15s   10.244.1.61   w1
filler-6b8d9f7c5-t9qkz   1/1     Running   0          15s   10.244.1.62   w1

2つとも w1 に載り、CPU の空きがほぼ無くなりました。 3つ目は入りません。確かめます。

bash
$ kubectl scale deployment filler --replicas=3
$ kubectl get pod -o wide -l app=filler
NAME                     READY   STATUS    RESTARTS   AGE   IP            NODE
filler-6b8d9f7c5-4xmnp   1/1     Running   0          1m    10.244.1.61   w1
filler-6b8d9f7c5-t9qkz   1/1     Running   0          1m    10.244.1.62   w1
filler-6b8d9f7c5-w2hdc   0/1     Pending   0          10s   <none>        <none>

予想どおり Pending。 戻します。

bash
$ kubectl scale deployment filler --replicas=2

優先度の高い Pod を入れる

vip.yaml を作ります。filler と同じ場所を、同じだけ要求します。

bash
$ nano vip.yaml
apiVersion: v1
kind: Pod
metadata:
  name: vip
spec:
  priorityClassName: high-priority
  nodeSelector:
    lab: preempt
  containers:
  - name: nginx
    image: nginx:1.27-alpine
    resources:
      requests:
        cpu: "900m"
bash
$ kubectl apply -f vip.yaml
$ kubectl get pod -o wide
NAME                     READY   STATUS        RESTARTS   AGE   IP            NODE     NOMINATED NODE
filler-6b8d9f7c5-4xmnp   1/1     Running       0          3m    10.244.1.61   w1       <none>
filler-6b8d9f7c5-t9qkz   0/1     Terminating   0          3m    10.244.1.62   w1       <none>
vip                      0/1     Pending       0          3s    <none>        <none>   w1

filler の片方が Terminating になりました。 誰も消していません。vip を置くために、スケジューラが場所を空けています。

vip は NODE 列が <none> のまま、NOMINATED NODE 列に w1 と出ていて Pending です。これは Pod の status.nominatedNodeName で、「ここに置く予定だが、まだ空くのを待っている」という意味です。

bash
$ kubectl get pod vip -o wide
NAME   READY   STATUS    RESTARTS   AGE   IP            NODE   NOMINATED NODE
vip    1/1     Running   0          25s   10.244.1.64   w1     <none>

入りました。 追い出された側の記録を読みます。

bash
$ kubectl get events --sort-by=.lastTimestamp | grep -i preempt | tail -3
2m   Normal   Preempted   pod/filler-6b8d9f7c5-t9qkz   Preempted by pod 8f2c... on node w1

Preempted by pod ... on node w1。 はっきり残ります。

そして、追い出された filler は Deployment 配下なので、別の場所を探し続けます。

bash
$ kubectl get pod -o wide -l app=filler
NAME                     READY   STATUS    RESTARTS   AGE   IP            NODE
filler-6b8d9f7c5-4xmnp   1/1     Running   0          5m    10.244.1.61   w1
filler-6b8d9f7c5-nz6rt   0/1     Pending   0          1m    <none>        <none>

Pending のままです。 nodeSelector で w1 に固定してあるので、逃げ場がありません。

「自分の Pod を優先する」は、「誰かの Pod を殺す」と同じことです。 優先度を上げるときは、必ず「何を追い出してよいか」を先に決めてください。

globalDefault: true の PriorityClass を作ると、指定していない全 Pod にその値が付きます。 これを高い値で作るとクラスタ中が奪い合いになります。 作らないでください。

preemptionPolicy: Never を書くと、「優先的に順番待ちはするが、他人は追い出さない」にできます。「先に並ぶ権利」だけが欲しいときはこちらです。

エビクション — 追い出しはスケジューラだけの仕事ではない

Pod が追い出される経路は2つあり、混同すると原因を探す場所を間違えます。

誰がいつ何を選ぶか記録の出方
スケジューラ(プリエンプション)新しい高優先度 Pod が置けないとき優先度の低い PodPreempted by ...
kubelet(ノードのエビクション)そのノードのメモリやディスクが枯渇したときQoS の低い Pod からEvicted / The node was low on resource

後者はスケジューラと無関係です。 ノードの kubelet が、自分が動き続けるために、自分の判断で Pod を殺します。 メモリ枯渇でノードごと固まるより、Pod を数個殺すほうがマシだからです。

選ばれる順番は、前回の QoS クラスで決まります。

QoS書き方追い出される順番
BestEffortrequests も limits も書いていない1番目(真っ先に死ぬ)
Burstablerequests < limits、または片方だけ2番目
Guaranteedrequests と limits が全部同じ値最後

ノードの状態は kubectl describe node の Conditions に出ます。

bash
$ kubectl describe node w1 | grep -A6 Conditions
Conditions:
  Type             Status  Reason
  ----             ------  ------
  MemoryPressure   False   KubeletHasSufficientMemory
  DiskPressure     False   KubeletHasNoDiskPressure
  PIDPressure      False   KubeletHasSufficientPID
  Ready            True    KubeletReady

DiskPressure が True になると、そのノードは新しい Pod を受け付けなくなります。 「なぜか1台だけ Pod が来ない」ときは、taint の前にここを見てください。 VM の学習環境では、使っていないイメージが溜まってこれが起きます(crictl rmi --prune や docker system prune で空けます)。

使い分けの判断表

全部やってきましたが、結論はこれです。

基本は、何も指定しないこと。

スケジューラは、空きの多いノードを選び、既定の散らばりも効かせてくれます。 何か書くのは、「書かないと困ることが実際に起きたとき」だけです。書けば書くほど、置けない条件が増えて Pending の原因になります。

やりたいこと使うもの注意
特にこだわりが無い何も書かない← 9割はこれ。まずここを疑う
その機能があるノードにしか置けない(GPU など)nodeAffinity の required条件が単純なら nodeSelector でもよい
できればSSDのノードに置きたいnodeAffinity の preferred満たされなくても何も出ない
レプリカをノードに散らしたいtopologySpreadConstraintsまず ScheduleAnyway から
絶対に同居させたくない(DBなど)podAntiAffinity の requiredレプリカ数 ≦ ノード数でないと Pending
通信の多いもの同士を近づけたいpodAffinity の preferredrequired は起動順の依存を作る
このノードを特定用途の専用にしたいtaint + tolerationノード側から言う。書き忘れによる侵入を防げる
これ以上 Pod を増やしたくないkubectl cordon動いているものはそのまま
ノードをメンテするので退避させたいkubectl drainNoExecute の taint より安全
止めたくない Pod があるPriorityClass誰かが追い出される。追い出してよいものを決めてから
とにかくこのノードに置きたいnodeName❌ 使わない。理由が出なくなる

もう1つ、この記事を通じての共通ルールがあります。

required 系preferred 系
満たせないなら置かない(Pending)満たせなくても置く(無言)
可用性より正しさを選ぶとき正しさより動くことを選ぶとき
Pending を自分で作れるので、事故に気付ける黙って偏るので、-o wide で見ないと気付けない

つまずいたところ

素直に書きます。全部踏みました。

1. nodeName で Pending にしたとき、原因が本当に分からなかった

describe の Events が空だったので、「Kubernetes が壊れた」と思いました。 ログを探し回って30分溶かしました。スケジューラが関与していないから記録が無い、と分かるまで発想できませんでした。

教訓: Pending + Events が空 = nodeName を疑う。

2. podAntiAffinity を書いたのに、まったく散らばらなかった

labelSelector を app: nginx と書いていました。Pod に貼ってあるラベルは app: web です。

エラーは出ません。 「app: nginx の Pod が居る場所を避けろ」と正しく解釈され、そんな Pod は1つも居ないので、避ける必要が無いと判断されただけです。

教訓: 効いていないときは、まず labelSelector が実物のラベルと一致しているか。 kubectl get pod --show-labels で見ます。

3. required と preferred で YAML の階層が違うことに気付かなかった

preferred は weight と podAffinityTerm の下に labelSelector が入りますが、required は直に並びます。 preferred の形のまま required に書き換えて、こう言われました。

error: error validating data: ValidationError(Deployment.spec.template.spec.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[0]): unknown field "podAffinityTerm"

教訓: unknown field はスペルミスとは限らない。「その階層には無い」という意味でもある。 kubectl explain で確認するのが速いです。

4. topologyKey にノード名を書いた

topologyKey: w1 と書きました。構文としては通ります。 w1 というラベルを持つノードが1台も無いので、「w1 というラベルを持たないノードは、そもそも対象外」という扱いになり、何も起きません。

教訓: topologyKey はラベルの「キー名」。 迷ったら kubernetes.io/hostname です。

5. taint を剥がし忘れて、翌日に丸1時間潰した

NoSchedule を貼ったまま VM を落として寝ました。翌日、まったく別の実験をしていて、なぜか w2 に Pod が行かない。 podAntiAffinity を疑い、nodeSelector を疑い、最後に describe node を見て気付きました。

教訓: 札は必ず剥がす。 そしてこの順で見る癖をつけます。

bash
$ kubectl describe node <ノード> | grep -i -e taints -e unschedulable

6. kubectl taint を剥がすとき、書式で3回失敗した

bash
$ kubectl taint nodes w2 maintenance=true:NoSchedule
error: node w2 already has maintenance taint(s) with same effect(s) and --overwrite is false

- を付け忘れて、貼り直そうとしていました。 ラベルの key- と同じ規則です。kubectl taint nodes w2 maintenance- でも剥がせます。

7. プリエンプションが起きず、vip がただ Pending になった

filler に priorityClassName を書き忘れていました。優先度を書かない Pod の優先度は 0 です。それでも vip(100000)のほうが高いので追い出せるはずですが、私はそのとき vip にも priorityClassName を書き忘れていました。 両方 0 なので、追い出す理由がありません。

教訓: kubectl get pod <名前> -o jsonpath='{.spec.priority}' で、実際に付いた数値を見る。

後片づけ

ここは必ずやってください。 貼った札とラベルを残すと、次にこのクラスタで何をやっても原因不明で詰まります。

1. 作った Pod と Deployment を消す

bash
$ kubectl delete deployment web filler
$ kubectl delete pod --ignore-not-found on-ssd need-fast-disk prefer-fast-disk maintenance-ok vip cache-near-web pin-w2 pin-ghost

2. taint を全部剥がす

bash
$ kubectl taint nodes w2 maintenance- evacuate-

剥がれたことを、全ノードぶん確認します。

bash
$ kubectl describe nodes | grep -i taints
Taints:             node-role.kubernetes.io/control-plane:NoSchedule
Taints:             <none>
Taints:             <none>

cp1 の1枚は残しておいてください。 これは最初から貼ってあったもので、剥がすとコントロールプレーンにアプリが載るようになります。

3. ラベルを全部剥がす

bash
$ kubectl label node w1 disktype- rack- lab-
$ kubectl label node w2 disktype- rack-
bash
$ kubectl get nodes -L disktype -L rack -L lab
NAME   STATUS   ROLES           AGE   VERSION   DISKTYPE   RACK   LAB
cp1    Ready    control-plane   14d   v1.33.1
w1     Ready    <none>          14d   v1.33.1
w2     Ready    <none>          14d   v1.33.1

3列とも空なら成功です。

4. cordon が残っていないか確認する

bash
$ kubectl get nodes

SchedulingDisabled が付いていたら剥がします。

bash
$ kubectl uncordon w1 w2

5. PriorityClass を消す

bash
$ kubectl delete priorityclass low-priority high-priority
$ kubectl get priorityclass

残るのは system-cluster-critical と system-node-critical の2つだけです。この2つは絶対に消さないでください。 クラスタの中核部品が追い出されるようになります。

6. YAML を片付ける

bash
$ rm -f pod-selector.yaml pod-affinity-required.yaml pod-affinity-preferred.yaml
$ rm -f web-spread.yaml web-spread-required.yaml web-spread-topo.yaml
$ rm -f cache-near.yaml pod-tolerate.yaml priority.yaml filler.yaml vip.yaml

7. 最後の確認

bash
$ kubectl get pod -A -o wide | grep -v kube-system
$ kubectl get nodes

自分で作ったものが1つも残っていなくて、3台とも Ready(SchedulingDisabled なし)なら、元どおりです。

[スクリーンショット: 04_cleanup-confirm.png] 後片づけ後に kubectl get nodes と kubectl describe nodes | grep -i taints を実行し、札とラベルが消えている画面を撮ってください。

まとめ — 理解できたこと

  • スケジューラは「置くとき」に一度だけ働く。 あとからノードが空いても、動いている Pod は移らない。 均したいなら kubectl rollout restart で作り直す
  • メンテ明けに uncordon しただけでは、戻したノードは空のまま。 必ず -o wide で偏りを見る
  • 決め方は2段階。 「絞り込み(置けないノードを外す)」→「点数付け(残りに点を付ける)」
  • Pending の原因は必ず1段階目。 偏りの原因は2段階目。 ここを分けるだけで、探す場所が半分になる
  • FailedScheduling の1行は、外れた理由と台数の内訳になっている。 0/3 nodes are available: 1 node(s) had untolerated taint..., 2 node(s) didn't match... を読む
  • nodeName は指定ではなく迂回。 スケジューラを通らないので、失敗しても Events に何も出ない。 Pending + Events が空 = nodeName
  • required は「無理なら置かない」、preferred は「無理でも置く」。 preferred が満たされなくても、警告は1行も出ない
  • IgnoredDuringExecution は「置いたあとの変更は無視する」。 ラベルを剥がしても、動いている Pod は追い出されない
  • podAntiAffinity の labelSelector には、自分自身のラベルを書く。 書き間違えても無言で効かなくなる
  • topologyKey は「何をもって同じ場所とみなすか」。 ノード名ではなくラベルのキー名。 迷ったら kubernetes.io/hostname
  • required の podAntiAffinity は、レプリカ数がノード数を超えた瞬間に Pending。 1台のクラスタならレプリカ2で止まる
  • topologySpreadConstraints は「偏りの許容量」を数字で書ける。 maxSkew は一番多い場所と少ない場所の差
  • DoNotSchedule は、ノードが1台落ちているときにレプリカを増やせなくする。 可用性のための設定が可用性を下げる
  • taint はノード側から拒否する仕組みで、既定が「拒否」。 Pod 側に書いて回るのと違い、書き忘れによる侵入が起きない
  • toleration は許可証であって指示書ではない。 「行ってもよい」だけで、「行け」ではない
  • NoExecute だけが、いま動いている Pod を追い出す。 退避させたいなら NoExecute ではなく kubectl drain
  • 全 Pod に not-ready / unreachable の toleration が 300 秒で自動的に付いている。 ノードが落ちてから Pod が移るまで数分かかるのはこれ
  • コントロールプレーンに Pod が載らないのは、taint が1枚貼ってあるだけ。 仕様ではなく設定。剥がせば載る
  • プリエンプションは「誰かを殺して場所を作る」こと。 優先度を上げる前に、何を追い出してよいか決める
  • 追い出しには2経路ある。 スケジューラのプリエンプションと、ノードの資源枯渇で kubelet がやるエビクション。後者は QoS の低い順
  • そして、基本は何も指定しない。 書いた条件は、そのまま Pending の原因になる

参考リンク


次に読む

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

記事
← 前の記事requestsとlimits — Pendingのまま動かない
→ 次の記事無停止アップデートとProbe — 更新中に502が出る

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

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

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

DevOps›Kubernetes — Scheduling
  • nodeSelector / affinity / topologySpread
  • taints と tolerations / 優先度とプリエンプション

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

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

コメント

コメントする

目次