Kubernetes

修改 Kubernetes Kube Proxy IPVS scheduler mode

2020-02-29

由於 kube-proxy 在 ipvs scheduler 的模式是 rr，這篇會教學如何在 kubernetes cluster 裡面改變 ipvs scheduler 的模式。

環境

目前有三台 node 所組成的 kubernetes cluster

1
2
3
4
5
# kubectl get nodes -o wide
NAME    STATUS   ROLES    AGE    VERSION   INTERNAL-IP     EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION      CONTAINER-RUNTIME
node1   Ready    master   5d7h   v1.16.6   192.168.0.121   <none>        Ubuntu 16.04.5 LTS   4.15.0-88-generic   docker://18.9.7
node2   Ready    master   5d7h   v1.16.6   192.168.0.146   <none>        Ubuntu 16.04.5 LTS   4.15.0-88-generic   docker://18.9.7
node3   Ready    <none>   5d7h   v1.16.6   192.168.0.250   <none>        Ubuntu 16.04.5 LTS   4.15.0-88-generic   docker://18.9.7

Kubernetes 裡面有一個 hello world deployment，並使用 NodePort 暴露 8080 port 的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# kubectl get all
NAME                         READY   STATUS    RESTARTS   AGE
pod/hello-868dc85486-8lvps   1/1     Running   0          3d2h
pod/hello-868dc85486-j2q7x   1/1     Running   0          3d2h
pod/hello-868dc85486-n2lvt   1/1     Running   0          3d2h
pod/hello-868dc85486-njcfn   1/1     Running   0          3d2h

NAME                 TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
service/kubernetes   ClusterIP      10.233.0.1      <none>          443/TCP          5d8h
service/node-port    NodePort       10.233.2.107    <none>          8080:31191/TCP   35h

NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/hello   4/4     4            4           3d2h

NAME                               DESIRED   CURRENT   READY   AGE
replicaset.apps/hello-868dc85486   4         4         4       3d2h

使用 ipvsadm 查看 ipvs 的 scheduler 模式，目前的模式是 rr。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# ipvsadm -ln
IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
  -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
TCP  169.254.25.10:31191 rr
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0         
TCP  172.17.0.1:31191 rr
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0         
TCP  192.168.0.121:31191 rr
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0
TCP  10.233.90.0:31191 rr
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0 
...

下一節將說明如何修改 ipvs scheduler 的方法。

方法

首先，IPVS scheduler 的設定是在 kube-proxy 的 ConfigMap 裡面。

1
kubectl edit cm kube-proxy -n kube-system

將 data.config.conf.ipvs.scheduler 裡的參數修改成其他的 scheduler 模式：

1
2
3
4
data:
  config.conf:
    ipvs:
      scheduler: sh

在 Service: IPVS proxy mode 裡面有提供以下的 scheduler 的模式：

  • rr: round-robin
  • lc: least connection (smallest number of open connections)
  • dh: destination hashing
  • sh: source hashing
  • sed: shortest expected delay
  • nq: never queue

或參考 IPVS wiki

刪除原有的 kube-proxy 的 pod，daemonset.apps/kube-proxy 會自動重新建立新的 kube-proxy Pod。

1
kubectl delete -n kube-system $(kubectl get all -n kube-system | grep pod/kube-proxy | cut -d ' ' -f 1)

再次使用 ipvsadm 查看 ipvs 的 scheduler 就會是修改後的狀態。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# ipvsadm -ln
IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
  -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
TCP  169.254.25.10:31191 sh
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0         
TCP  172.17.0.1:31191 sh
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0         
TCP  192.168.0.121:31191 sh
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0
TCP  10.233.90.0:31191 sh
  -> 10.233.90.16:8080            Masq    1      0          0         
  -> 10.233.92.16:8080            Masq    1      0          0         
  -> 10.233.92.17:8080            Masq    1      0          0         
  -> 10.233.96.12:8080            Masq    1      0          0

Reference

RBAC Kubernetes 安裝 helm

2019-07-04

環境

  • Google Kubernetes Engine
  • Kubernetes version 1.12.8
  • Helm version 2.14.1

安裝 Helm without RBAC

Helm 是 Kubernetes 的管理工具，Tiller 則是 API server，至於之間的差別，Helm 是 Client 端，Tiller 是 Server 端。輸入以下指令會安裝 Helm 和 Tiller：

1
helm init

官方文件建議加上 –history-max 參數，限制最大歷史指令的數量，如果沒有設定最大歷史記錄，則永遠保留歷史記錄。

1
helm init --history-max 200

##設定 RBAC

在雲端平台上，由於有安全性的問題，如果不設定 RBAC，之後可能會無法正常使用，所以需要提供足夠的權限給 tiller，輸入以下指令建立權限，ServiceAccount 的名稱為 tiller：

1
2
kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller

套用 tiller 的 ServiceAccount 到已經現有的上

1
kubectl patch deployment --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'

安裝 Helm with RBAC

所有設定一次到位，在 helm init 的時候，加了 –service-account 參數，直接套用 ServiceAccount：

1
2
3
kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
helm init --service-account tiller --history-max 200

測試

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
$ helm install --name my-db stable/influxdb
NAME:   my-db
LAST DEPLOYED: Wed Jul  3 23:13:08 2019
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME            DATA  AGE
my-db-influxdb  1     1s

==> v1/PersistentVolumeClaim
NAME            STATUS   VOLUME    CAPACITY  ACCESS MODES  STORAGECLASS  AGE
my-db-influxdb  Pending  standard  1s

==> v1/Pod(related)
NAME                             READY  STATUS   RESTARTS  AGE
my-db-influxdb-689d74646c-6fwc4  0/1    Pending  0         1s

==> v1/Service
NAME            TYPE       CLUSTER-IP     EXTERNAL-IP  PORT(S)            AGE
my-db-influxdb  ClusterIP  10.11.249.197  <none>       8086/TCP,8088/TCP  1s

==> v1beta1/Deployment
NAME            READY  UP-TO-DATE  AVAILABLE  AGE
my-db-influxdb  0/1    1           0          1s

...

查看套件清單

1
2
3
$ helm ls
NAME    REVISION        UPDATED                         STATUS          CHART           APP VERSION     NAMESPACE
my-db   1               Wed Jul  3 23:13:08 2019        DEPLOYED        influxdb-1.1.9  1.7.6           default

刪除測試檔案，–purge 參數可以徹底刪除，不留下任何記錄，名稱可以透過上面的指令查詢：

1
helm delete --purge my-db

解除安裝 Helm

1
2
3
kubectl -n kube-system delete deployment tiller-deploy
kubectl delete clusterrolebinding tiller
kubectl -n kube-system delete serviceaccount tiller

Reference

在 kubernetes 上建立 influxdb 1.7.7

2019-07-03

環境

  • Google Kubernetes Engine
  • Kubernetes 版本為 1.12.8

建立 Secret

Kubernetes secret 可以存放重要訊息，像是使用者密碼之類，不適合暴露在外。

設定以下參數，稍後提供給 influxdb 使用：

  1. INFLUXDB_DATABASE：資料庫名稱
  2. INFLUXDB_HOST：主機名稱
  3. INFLUXDB_USERNAME：使用者名稱
  4. INFLUXDB_PASSWORD：使用者密碼
1
2
3
4
5
kubectl create secret generic influxdb-creds \
  --from-literal=INFLUXDB_DATABASE=db \
  --from-literal=INFLUXDB_USERNAME=root \
  --from-literal=INFLUXDB_PASSWORD=root \
  --from-literal=INFLUXDB_HOST=influxdb

輸入以下指令檢查參數是否設定完成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ kubectl get secrets
NAME                  TYPE                                  DATA   AGE
influxdb-creds        Opaque                                4      46m

$ kubectl describe secrets influxdb-creds
Name:         influxdb-creds
Namespace:    default
Labels:       <none>
Annotations:  <none>
Type:  Opaque
Data
====
INFLUXDB_DATABASE:  12 bytes
INFLUXDB_HOST:      8 bytes
INFLUXDB_PASSWORD:  4 bytes
INFLUXDB_USERNAME:  4 bytes

密文型態為 Opaque，裡面有四筆資料

建立儲存空間 Persistent Volume Claim (PVC)

使用 Kubernetes PVC 宣告儲存空間，將儲存空間命名為 influxdb，容量大小 2GB：

1
2
3
4
5
6
7
8
9
10
11
12
13
# pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  labels:
    app: influxdb
  name: influxdb
spec:
  accessModes:
  - ReadWriteOnce
      resources:
    requests:
      storage: 2Gi

套用設定：

1
kubectl apply -f pvc.yaml

建立 Deployment

直接使用 Docker Hub 上的 influxdb，版本為 1.7.7

1
kubectl run influx-deployment --image=influxdb:1.7.7

套用 Secret

套用先前設定的 influxdb-creds Secret，輸入以下指令進入修改模式：

1
kubectl edit deployment influxdb

在 spec.template.spec.containers 位置加入 kubernetes secret：

1
2
3
4
5
6
7
8
spec:
  template:
    spec:
      containers:
      - name: influxdb
        envFrom:
        - secretRef:
            name: influxdb-creds

套用 Persistent Volume Claim (PVC)

套用先前設定的 influxdb PVC，輸入以下指令進入修改模式：

1
kubectl edit deployment influxdb

在 spec.template.spec.volumes 位置加入 Persistent Volume Claim (PVC)：

1
2
3
4
5
6
7
spec:
  template:
    spec:
      volumes:
      - name: var-lib-influxdb
        persistentVolumeClaim:
          claimName: influxdb

並且在 spec.template.spec.containers.volumeMounts 位置加入 Persistent Volume (PV)：

1
2
3
4
5
6
7
spec:
  template:
    spec:
      containers:
        volumeMounts:
        - mountPath: /var/lib/influxdb
          name: var-lib-influxdb

最後整份文件的結果會長得如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "4"
  creationTimestamp: 2019-07-02T15:59:33Z
  generation: 4
  labels:
    run: influxdb
  name: influxdb
  namespace: default
  resourceVersion: "15136"
  selfLink: /apis/apps/v1/namespaces/default/deployments/influxdb
  uid: 62295880-9ce2-11e9-8f7f-42010a8000e8
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 2
  selector:
    matchLabels:
      run: influxdb
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: influxdb
    spec:
      containers:
      - envFrom:
        - secretRef:
            name: influxdb-creds
        image: docker.io/influxdb:1.7.7
        imagePullPolicy: IfNotPresent
        name: influxdb
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /var/lib/influxdb
          name: var-lib-influxdb
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
      volumes:
      - name: var-lib-influxdb
        persistentVolumeClaim:
          claimName: influxdb
status:
  ...

Expose Service

這裡使用 LoadBalancer 來 expose 我們的服務，需要有雲端平台的支援：

1
kubectl expose deployment influx-deployment --name=influx-service --type=LoadBalancer --port=8086 --target-port=8086

若 EXTERNAL-IP 顯示為 pending，則再過一陣再重輸入一次。

1
2
3
$ kubectl get service
NAME             TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)          AGE
influxdb         LoadBalancer   10.11.255.248   34.68.51.223   8086:31365/TCP   69m

看到 IP address 就代表完成了，接下來就測試看看是否能連進 server。

測試

從是否能從外部連進來：

1
2
3
4
5
6
7
$ influx --version
InfluxDB shell version: 1.7.7

$ influx -host '34.68.51.223' -port '8086' -username 'root' -password 'root'
Connected to http://34.68.51.223:8086 version 1.7.7
InfluxDB shell version: 1.7.7
>

Reference

在 Ubuntu 上重新安裝 Kubernetes

2019-04-26

介紹

Kubeadm 有提供一個指令 reset，不過他只會將有關 Kubernetes 的東西刪除，像是 flannel、cni 的網路設定，則必須要手動刪除。

這裡使用的環境是：

  • Ubuntu 18.04
  • Kubernetes 1.14.1
  • Flannel 0.10.0

Problem

要讓問題重現，只需要在你安裝好 Kubernetes Cluster 之後，重設 Kubernetes 就會發生：

1
2
kubeadm reset -f
kubeadm init

這個時候你的 coredns 會一直在 pending 的狀態，而且 nodes 會一直是 NodReady：

1
2
3
4
5
6
7
8
$ kubectl get nodes
NAME      STATUS     ROLES    AGE   VERSION
akiicat   NotReady   master   65m   v1.14.1

$ kubectl get pod -n kube-system
NAME                      READY   STATUS    RESTARTS   AGE
coredns-fb8b8dccf-2t48c   0/1     Pending   0          42s
coredns-fb8b8dccf-x7f87   0/1     Pending   0          42s

看一下 kubelet 是什麼問題，猜測是之前的 CNI 沒有清除乾淨，而套用到舊的資料

1
2
3
4
$ systemctl status kubelet
...
 4月 25 14:01:40 akiicat kubelet[6416]: W0425 14:01:40.779474    6416 cni.go:213] Unable to update cni config: No networks found in /etc/cni/net.d
 4月 25 14:01:40 akiicat kubelet[6416]: E0425 14:01:40.901231    6416 kubelet.go:2170] Container runtime network not ready: NetworkReady=false reason:NetworkPluginNotReady message:docker: network plugin is not ready: cni config uninitialized

Step by Step

接下來就一步一步的解決這個問題，首先切換成 root 權限：

1
sudo su -

先把 Kubernetes 重設，-f 參數代表強制執行 reset，不會跳出提示訊息的確認：

1
kubeadm reset -f

停止 kubelet、docker：

1
2
systemctl stop kubelet
systemctl stop docker

完全刪除 cni、flannel 的資料：

1
2
3
4
rm -rf /var/lib/cni/
rm -rf /var/lib/kubelet/*
rm -rf /run/flannel
rm -rf /etc/cni/

移除 cni、flannel 的網路介面卡：

1
2
3
ifconfig cni0 down
brctl delbr cni0
ifconfig flannel.1 down

重新啟動 docker：

1
systemctl start docker

這樣就完成了，最後檢查一下網路介面卡與 IP table 有沒有 flannel、cni：

1
2
ifconfig
route -n

沒有在這上面就成功了。

後續安裝可以參考我寫的這篇文章：Bare Metal 在 Ubuntu 上安裝 Kubernetes

Summary

最後要輸入指令的時候，需要對 Master 跟 Worker 執行不同的指令，以及在不同的權限下執行：

  • Master：代表主結點。
  • Node：代表 Worker 節點或子結點。

[Master, Node] 不管事 master 跟 worker 都要執行 Kubernetes Reset，在執行時要注意權限是否正確：

1
2
3
4
5
6
7
8
9
10
11
12
# root
kubeadm reset -f
systemctl stop kubelet
systemctl stop docker
rm -rf /var/lib/cni/
rm -rf /var/lib/kubelet/*
rm -rf /run/flannel
rm -rf /etc/cni/
ifconfig cni0 down
brctl delbr cni0
ifconfig flannel.1 down
systemctl start docker

[Master] 安裝 Kubernetes：

1
2
# root
kubeadm init --pod-network-cidr 10.244.0.0/16

注意要切換使用者：

1
2
3
4
5
6
# user
mkdir -p $HOME/.kube
sudo cp -f /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/bc79dd1505b0c8681ece4de4c0d86c5cd2643275/Documentation/kube-flannel.yml

[Node] 加入 worker 節點：

1
2
3
# root
kubeadm join 192.168.0.11:6443 --token 3c564d.6q2we53btzqmf1ew \
    --discovery-token-ca-cert-hash sha256:a5480dcd68ec2ff27885932ac80d33aaa0390d295d4834032cc1eb554de3d5d2

Reference

管理多個 Kubernetes Cluster：建立、切換、合併 context

2019-04-24

用途

要存取某個 Kubernetes 的 cluster，必須先設定好 Kubernetes 的 context，context 裡面會描述要如何存取到你的 Kubernetes 的 cluster。

當你今天有兩個 Kubernetes 的 cluster 的時候，分別是正式版的 cluster 跟測試用的 cluster，很頻繁在這兩個 cluster 作切換，這時候只需要分別對兩個不同的 context 就可以了，然後利用 kubectl 提供的指令，就能在不同的 cluster 作切換。

雖然目前還用不到兩個 cluster，但我還是建議先設定這個檔案，因為在還沒有設定這個檔案前，你可能會需要 ssh 遠端回你的主機才能使用 kubectl 指令，不過你可以在本地端設定這份檔案，就不需要遠端回你的主機了。

能夠有這些方便的功能，都是建立在你已經在本地端建立好你的設定檔。

Context

在 Kubernetes 裡面，切換不同的 cluster 是以 context 為單位，一個 context 裡面必需要三個元件，分別是 User、Server、Certification。這三個東西說起來也很直觀，有個使用者 (User) 必須要有憑證 (Certification) 才能連到某個 Cluster (Server)。

底下是一個 Context 所包含的內容：

1
2
3
4
5
6
7
8
9
                                    +---------------+
                                +---+ Certification |
                  +---------+   |   +---------------+
              +---+ Cluster +---+
+---------+   |   +---------+   |   +--------+
| Context +---+                 +---+ Server |
+---------+   |   +------+          +--------+
              +---+ User |
                  +------+

Server 跟 Certification 會一起放在 Cluster 底下，這麼做的好處是，如果今天有兩個不同的使用者，想要連到同一個 Cluster，則不需要重新輸入一次 Certification 跟 Server。

通常設定檔會放在 $HOME/.kube/ 底下，然後檔名命名為 config，不需要副檔名，當你使用 kubectl 指令的時候，預設就會使用這個設定檔。

這裡提供一個設定檔的範例，裡面的架構就如同上面的圖，可以對照著看，我也加了些註解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# $HOME/.kube/config
apiVersion: v1
kind: Config
preferences: {}
current-context: kubernetes-admin@kubernetes # 預設使用哪個 Context

clusters:
- cluster:
    certificate-authority: .minikube/ca.crt
    server: https://192.168.99.100:8443
  name: minikube         # Cluster 的名稱，可在 Context 使用
- cluster:
    certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS...
    server: https://17.82.125.39:6443
  name: kubernetes
  
contexts:
- context:
    cluster: minikube    # 選則某個 Cluseter
    user: minikube       # 選則某個 User
  name: minikube         # 這個 Context 的名稱
- context:
    cluster: kubernetes
    user: kubernetes-admin
  name: kubernetes-admin@kubernetes
- context:
    cluster: kubernetes
    user: kubernetes-admin
    namespace: kube-system  # 指定 namesapce，若不指定預設為 default
  name: kubernetes-system@kubernetes

users:
- name: kubernetes-admin
  user:
    client-certificate-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0...
    client-key-data: LS0tLS1CRUdJTiBSU0EgUF...
- name: minikube         # User 的名稱，可在 Context 使用
  user:
    client-certificate: .minikube/client.crt
    client-key: .minikube/client.key

如果路徑正確，檔名正確，設定內容正確，就能看一下我們目前狀態：

1
2
3
4
5
$ kubectl config get-contexts
CURRENT   NAME                           CLUSTER      AUTHINFO           NAMESPACE
*         kubernetes-admin@kubernetes    kubernetes   kubernetes-admin   
          kubernetes-system@kubernetes   kubernetes   kubernetes-admin   kube-system
          minikube                       minikube     minikube

第二欄 NAME 就是 context 的名稱，透過 use-context 指令就能夠在不同的設定檔作切換：

1
kubectl config use-context <context-name>

像是這樣：

1
2
3
4
5
6
7
8
$ kubectl config use-context minikube
Switched to context "minikube".

$ kubectl config get-contexts
CURRENT   NAME                           CLUSTER      AUTHINFO           NAMESPACE
          kubernetes-admin@kubernetes    kubernetes   kubernetes-admin   
          kubernetes-system@kubernetes   kubernetes   kubernetes-admin   kube-system
*         minikube                       minikube     minikube

路徑

尋找設定檔的優先順序：

  1. 優先使用環境變數 $KUBECONFIG 所設定的路徑
  2. 如果沒有設定 $KUBECONFIG 環境變數，則使用 ${HOME}/.kube/config

假設想要使用其他的設定檔 /tmp/admin.conf，那可以這樣輸入：

1
export KUBECONFIG=/tmp/admin.conf

這看起來並不是非常好用，如果你要切換某個 context 的時候，還需要設定 KUBECONFIG 的路徑，如果能把所有 context 整合在一起就會好用多了。

Merge

Kubernetes 目前並沒有 kubectl config merge 的指令，不過在未來可能會有，有興趣的話可以參考這篇 Github 上的討論。

暫時性

目前解決方法是用冒號 : 將不同的檔案串在一起，放在越前面的檔案，順位越高：

1
export KUBECONFIG=${HOME}/.kube/config:/tmp/admin.conf

或是在每次輸入指令前都加上 KUBECONFIG 的設定：

1
KUBECONFIG=${HOME}/.kube/config:/tmp/admin.conf kubectl config get-contexts

永久性

直接寫進 bashrc，每當開啟終端機的時候都會套用環境變數：

1
2
# ~/.bashrc
export KUBECONFIG=${HOME}/.kube/config:/tmp/admin.conf

一勞永逸地做法，把新的檔案跟 ${HOME}/.kube/config 合併：

1
KUBECONFIG=${HOME}/.kube/config:/tmp/admin.conf kubectl config view --flatten > mergedkub && mv mergedkub ${HOME}/.kube/config

另外還有腳本：

1
2
3
4
# ~/.bashrc
function kmerge() {
  KUBECONFIG=~/.kube/config:$1 kubectl config view --flatten > ~/.kube/mergedkub && mv ~/.kube/mergedkub ~/.kube/config
}

使用方法：

1
$ kmerge /tmp/admin.conf

Reference

在本地端上建立 Kubernetes Dashboard

2019-04-23

Installation

在安裝 Dashboard 之前，請先確認你的 Kubernetes 已經裝好了，至於怎麼安裝 Kubernetes 就自行 Google 拉。

接下來我們要開始安裝 Github Kubernetes Dashboard，官網上其實已經說明的很清楚，不過這裡在記錄一下安裝的過程：

1
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v1.10.1/src/deploy/recommended/kubernetes-dashboard.yaml

沒有錯，這樣就安裝好了，然後看一下正在運行的容器：

1
2
3
4
5
6
7
8
9
10
11
12
$ kubectl get all -n kube-system -l k8s-app=kubernetes-dashboard
NAME                                        READY   STATUS    RESTARTS   AGE
pod/kubernetes-dashboard-5f7b999d65-sswt4   1/1     Running   0          84m

NAME                           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
service/kubernetes-dashboard   ClusterIP   10.102.216.229   <none>        443/TCP   84m

NAME                                   READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/kubernetes-dashboard   1/1     1            1           84m

NAME                                              DESIRED   CURRENT   READY   AGE
replicaset.apps/kubernetes-dashboard-5f7b999d65   1         1         1       84m

Access

接下來我們要連到 Dashboard，先把 kubectl proxy 打開：

1
kubectl proxy

然後連到下面的網址，就能夠看到 Kubernetes Dashboard：

http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/

到這裡就已經可以看到登入畫面了，不過這裡要注意的是，如果你是使用 ssh 連到你的主機的話，要先在本地端設定好 kubectl，在本地端輸入 kubectl proxy

建立 RBAC

Service Account

建立一個 service 的帳戶

1
2
3
4
5
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kube-system

ClusterRoleBinding

將剛剛建立的 Service Account admin-user 與 ClusterRole 做綁定

1
2
3
4
5
6
7
8
9
10
11
12
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kube-system

這樣就這定好了

Login with Token

生成 admin-user 的 token：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep admin-user | awk '{print $1}')
Name:         admin-user-token-ctr9s
Namespace:    kube-system
Labels:       <none>
Annotations:  kubernetes.io/service-account.name: admin-user
              kubernetes.io/service-account.uid: b2a411d9-64c9-11e9-a59d-1c872c43607f

Type:  kubernetes.io/service-account-token

Data
====
ca.crt:     1025 bytes
namespace:  11 bytes
token:      eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJhZG1pbi11c2VyLXRva2VuLWN0cjlzIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImFkbWluLXVzZXIiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC51aWQiOiJiMmE0MTFkOS02NGM5LTExZTktYTU5ZC0xYzg3MmM0MzYwN2YiLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6a3ViZS1zeXN0ZW06YWRtaW4tdXNlciJ9.wA-CiA6yqJnxDJgQEX0pes32RGm9I_eh0fOoT6oEuLN849FhuNHPJ-LquEm9TFOVs944NXner_fq8czncrQUSiCmErH5ms6mSmXT8Ql-PjDWUCSpwb6rrDd8GCFSLA4LYZbgNQMiD21q2KY8HN3djW0QK1kcl3Cc19lyeAYMQ6DL6WU1AWzlsZEzAkd_P6r8a6KXrDxZNRimIzl61yioVmLqPGN3imT0u3DUvedbDReWVSTBYvOEExvgchgKKuImr0i1V2m7GbfJ01kDwKcehh78YPPMtXG-wfwVLA9xancHtoP0exPQ15fx9fQvswEoH1Qwz5T4dA2TYXKzHweZvg

最後登入的時，使用 Token 登入，將 Token 複製貼上就能夠登入了。

Trouble Shooting

Address already in use

如果你是背景執行 proxy 指令的話：

1
kubectl proxy &

在這個時候，沒有關掉這個程式，直接關掉終端機，再次執行則會發現 port 已經被佔用了，顯示的錯誤如下：

1
F0422 16:14:59.688258   15922 proxy.go:158] listen tcp 127.0.0.1:8001: bind: address already in use

方法一

如果你執行 proxy 的終端機還開著，可以使用 fg 指令把程式叫回，在按 Ctrl-C 即可：

方法二

萬一你把執行 proxy 的終端機關閉了，則必須先找到執行 proxy 的執行緒 pid：

1
2
3
4
5
6
7
8
$ netstat -tulp | grep kubectl
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
tcp        0      0 localhost:8001          0.0.0.0:*               LISTEN      15908/kubectl
# 或是
$ ps -ef | grep kubectl
akiicat  15908  7633  0 16:14 pts/1    00:00:00 kubectl proxy
akiicat  20117  7633  0 16:23 pts/1    00:00:00 grep --color=auto kubectl

找到 pid，上面的例子的 pid 是 15908，然後程式強制刪除：

1
kill -9 <pid>

Reference

Kubernetes MetalLB Load Balancer 設定多個 address pool

2019-04-22

Before Start

首先你先要安裝好：

  • Kubernetes 1.9 版以上，以及可以使用 kubeadm、kubectl 、kubelet 指令
  • MetalLB Layer2 Load Balancer

由於我們會使用 bgp 的 protocol，可以直接在 minikube 上使用，如果你是在 bare metal 上操作的話，必須做額外的設定，可以參考官方文件。

Configure Load Balancer

MetalLB 設定 Load Balancer 需要提供 ConfigMap 裡面包涵我們給定的網段範圍

會需要分別使用不同的 address pool 是有原因的，有申請過網路的都知道，固定 IP 是很貴的，而且數量有限，只會在有需要的時候才會使用公開固定 IP 網域池，像是產品 production 的網頁。

至於其他還在測試 staging 的網頁，使用私人網域池即可，最後在設定個 VPN 連線進來看，就能夠減少申請固定 IP 的費用。

這裡我們建立了兩個網域池，相關的設定如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: production
      protocol: bgp
      auto-assign: false
      addresses:
      - 17.95.16.28-17.95.16.32
    - name: staging
      protocol: bgp
      avoid-buggy-ips: true
      addresses:
      - 192.168.144.0/20
address pool 1 address pool 2
名稱 production staging
協定 bgp bgp
網段 17.95.16.28-17.95.16.32 192.168.144.0/20

這裡假設我們申請到這個範圍的固定 IP 17.95.16.28-17.95.16.32，可以供 Load Balancer 來分配。

至於設定 avoid-buggy-ips: true 參數的話， MetalLB 避免 .0 跟 .255 的 IP。

如果想要手動指派 IP 的話，可以設定成 auto-assign: false，不設定的話預設是 true。

寫好設定檔，我們就立即套用它：

1
kubectl apply -f configmap.yaml

測試

現在我們來測試剛剛設定的 Load Balancer 有沒有成功。

我會執行兩份 deployment，一個會使用 production 的網域池，另一個會使用 staging 的網域池，兩個設定檔分別是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# hello-production.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-production
  labels:
    run: hello-production
spec:
  replicas: 3
  selector:
    matchLabels:
      run: hello-production
  template:
    metadata:
      labels:
        run: hello-production
    spec:
      containers:
      - name: hello-production
        image: k8s.gcr.io/echoserver:1.10
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: hello-production
  annotations:
    metallb.universe.tf/address-pool: production
spec:
  ports:
  - port: 8080
    targetPort: 8080
  selector:
    run: hello-production
  type: LoadBalancer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# hello-staging.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-staging
  labels:
    run: hello-staging
spec:
  replicas: 3
  selector:
    matchLabels:
      run: hello-staging
  template:
    metadata:
      labels:
        run: hello-staging
    spec:
      containers:
      - name: hello-staging
        image: k8s.gcr.io/echoserver:1.10
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: hello-staging
  annotations:
    metallb.universe.tf/address-pool: staging
spec:
  ports:
  - port: 8080
    targetPort: 8080
  selector:
    run: hello-staging
  type: LoadBalancer

這裡需要在 metadata.annotations 裡面設定 metallb.universe.tf/address-pool: staging 參數，後面接值必須跟前面 ConfigMap 裡 address pool 的名稱一樣。

1
2
3
metadata:
  annotations:
    metallb.universe.tf/address-pool: staging

然後套用設定：

1
kubectl apply -f hello-production.yaml,hello-staging.yaml

查看我們現在正在運行的容器與網路設定：

1
2
3
4
5
6
7
8
9
10
11
12
$ kubectl get pods
NAME                               READY   STATUS    RESTARTS   AGE
hello-production-b58c4488d-fxj7d   1/1     Running   0          19m
hello-production-b58c4488d-kx2nh   1/1     Running   0          19m
hello-production-b58c4488d-tp8f6   1/1     Running   0          19m
hello-staging-c8fc9f69d-4gmfr      1/1     Running   0          19m
hello-staging-c8fc9f69d-rhh7q      1/1     Running   0          19m
hello-staging-c8fc9f69d-vdwt2      1/1     Running   0          19m
$ kubectl get service
NAME               TYPE           CLUSTER-IP       EXTERNAL-IP      PORT(S)          AGE
hello-production   LoadBalancer   10.109.99.105    17.95.16.28      8080:31532/TCP   19m
hello-staging      LoadBalancer   10.110.199.100   192.168.144.1    8080:32603/TCP   19m

有被分配到外部固定 IP 的 service，就能夠使用透過外面的網路連進來，可以馬上找其他電腦來試試。

Reference

MetalLB 在 Kubernetes Bare Metal 上安裝 Layer 2 Load Balancer

2019-04-19

準備

假設你已經先裝好 Kubernetes cluster 了，由於是 bare metal，你必須把 Kubernetes 裝載三台不同電腦上，或是使用三個 Raspberry Pi，然後使用 kubeadm 指令串起來。

Cluster Addresses

我們現在有三台電腦，它的名稱與 IP 分別是：

  • Master：192.168.1.100

  • Node1：192.168.1.101

  • Node2：192.168.1.102

    當你在安裝電腦時，名稱與 IP 必須是唯一的，否則在 join 的時候會出現錯誤。

這裡使用的 IP 是 DHCP 所分配的 IP，IP 的範圍是 192.168.1.100—192.168.1.150，如果你有足夠的 public IP address，可以分別對每台電腦做設定。

假設我申請了 17.95.16.0-17.95.16.32，就可以把 IP 設定成這樣：

  • Master：17.95.16.1
  • Node1：17.95.16.2
  • Node2：17.95.16.3

雖然只用了三個，但我們保留剩下的 17.95.16.10-17.95.16.32 讓 Load Balancer 來分配這些網址

Metallb

安裝 metallb 的步驟非常的簡單：

1
kubectl apply -f https://raw.githubusercontent.com/google/metallb/v0.7.3/manifests/metallb.yaml

然後查看目前的狀態，是否有一個 controller 跟多個 speaker：

1
2
3
4
5
$ kubectl get pods -n metallb-system
NAME                         READY   STATUS    RESTARTS   AGE
controller-cd8657667-2znm8   1/1     Running   0          22h
speaker-m95vd                1/1     Running   0          22h
speaker-shq8s                1/1     Running   0          22h

因為我們還沒有提供 load balance 的網址給他，所以接下來要設定 ConfigMap

Configure

架設我們想提供 load balance 的網址是 192.168.1.240-192.168.1.250，看一下我們的設定檔：

1
2
3
4
5
6
7
8
9
10
11
12
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: my-ip-space
      protocol: layer2
      addresses:
      - 192.168.1.240-192.168.1.250

我們把 protocol: layer2 套用在 192.168.1.240-192.168.1.250 這個網段上

如果想要使用外網的話，直接把網段的範圍改成外網即可

MetalLB 提供了 layer2 跟 bgp 兩種 protocol，這裡使用 layer2，如果使用 bgp 的話還需要另外做設定，可以參考官方文件。

套用上面的 ConfigMap：

1
kubectl apply -f https://raw.githubusercontent.com/google/metallb/v0.7.3/manifests/example-layer2-config.yaml

查看 Log：

1
kubectl logs -l component=speaker -n metallb-system

測試

執行一些簡單的容器，然後使用 LoadBalancer 暴露它：

1
2
kubectl run hello-world --image=k8s.gcr.io/echoserver:1.10 --port=8080 --replicas=3
kubectl expose deployment hello-world --type=LoadBalancer

查看 pods 是否有在運行

1
2
3
4
5
6
7
8
$ kubectl get pods
NAME                                 READY   STATUS             RESTARTS   AGE
pod/hello-world-6cdb64fdcd-7bfgq   1/1     Running            0          17s
pod/hello-world-6cdb64fdcd-82mtv   1/1     Running            0          17s
pod/hello-world-6cdb64fdcd-rhxp2   1/1     Running            0          17s
$ kubectl get service
NAME          TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)          AGE
hello-world   LoadBalancer   10.106.40.173   192.168.1.240    8080:30700/TCP   11s

我們現在有外部 IP 了！馬上測試看看能不能連得到：

1
2
3
$ curl 192.168.1.240:8080
Hostname: hello-world-1-6cdb64fdcd-7bfgq
...

如果有看到跟請求 http 有關的資訊的話，就代表你成功了。

Reference

Bare Metal 在 Ubuntu 上安裝 Kubernetes

2019-04-18

Docker

在安裝 Kubernetes 前要先安裝好 Docker，可以參考這篇：

在 Ubuntu 18.04 上安裝 Docker CE

Kubeadm

kubeadm 負責管理節點，可以透過方便的指令將電腦加入 cluster，在這裡我們先定義：

  • Master：代表主結點，負責控制與分發任務
  • Node：代表子結點，負責執行 Master 所分發的任務

[Master, Node] 安裝 Kubeadm 需要 root 權限：

1
sudo su -

[Master, Node] 安裝 kubeadm：

1
2
3
4
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" > /etc/apt/sources.list.d/kubernetes.list
apt update
apt install -y kubeadm

apt 安裝 kubeadm 完後會連同 kubelet 跟 kubectl 一起安裝。

[Master] 在 Master 節點上初始化 Kubernetes：

1
kubeadm init --pod-network-cidr 10.244.0.0/16

因為我們是使用 flannel，所以必須加上 --pod-network-cidr。

我們這邊選擇 flannel 的是因為 flannel 支援 arm。

如果要透過 WIFI 連接網路的話，需要加上 --apiserver-advertise-address=<wifi-ip-address> 參數到 kubeadm init 指令上。

執行 kubeadm init 之後會有一行 kubeadm join，如果弄丟的話，可以執行下面指令獲得：

1
kubeadm token create --print-join-command

[Node] 然後把其他的 node 加進來：

1
2
kubeadm join 192.168.0.11:6443 --token 3c564d.6q2we53btzqmf1ew \
    --discovery-token-ca-cert-hash sha256:a5480dcd68ec2ff27885932ac80d33aaa0390d295d4834032cc1eb554de3d5d2

[Master, Node] 離開 root：

1
exit

Kubectl

[Master] 回到使用者模式後執行：

1
2
3
mkdir -p $HOME/.kube
sudo cp -f /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

將 admin.conf 放置到 ~/.kube/config 就會自動抓取設定檔。

[Master] 安裝 flannel，相關文件在 CoreOS 上：

1
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/bc79dd1505b0c8681ece4de4c0d86c5cd2643275/Documentation/kube-flannel.yml

[Master] 查看目前節點：

1
2
3
4
$ kubectl get nodes
NAME            STATUS   ROLES    AGE   VERSION
akiicat         Ready    master   77m   v1.14.1
akiicat-node2   Ready    <none>   51s   v1.14.1

測試

執行一些簡單的容器：

1
kubectl run kuard --image=gcr.io/kuar-demo/kuard-amd64:blue --replicas=3

查看 pods 是否有在運行

1
2
3
4
5
$ kubectl get pods
NAME                         READY   STATUS             RESTARTS   AGE
kuard-6cdb64fdcd-7bfgq       1/1     Running            0          17s
kuard-6cdb64fdcd-82mtv       1/1     Running            0          17s
kuard-6cdb64fdcd-rhxp2       1/1     Running            0          17s

使用 LoadBalancer 暴露它：

1
kubectl expose deployment kuard --type=LoadBalancer --port=80 --target-port=8080

查看 Service

1
2
3
4
5
6
7
8
9
10
11
12
$ kubectl describe service/kuard
Name:                     kuard
...
Type:                     LoadBalancer
IP:                       10.109.141.84
Port:                     <unset>  8080/TCP
TargetPort:               8080/TCP
NodePort:                 <unset>  30034/TCP
Endpoints:                10.244.1.5:8080,10.244.1.6:8080,10.244.1.7:8080
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

使用 curl 連到 pod 的 endpoint：

1
2
3
$ curl 10.244.1.5:8080
Hostname: kuard-1-6cdb64fdcd-7bfgq
...

Trouble Shooting

Swap Error

當你用 root 權限執行 kubeadm init 時，會出現 ERROR Swap 的錯誤：

1
2
3
4
5
6
7
8
9
# kubeadm init --pod-network-cidr 10.244.0.0/16
[init] Using Kubernetes version: v1.14.1
[preflight] Running pre-flight checks
[preflight] WARNING: Couldn't create the interface used for talking to the container runtime: docker is required for container runtime: exec: "docker": executable file not found in $PATH
error execution phase preflight: [preflight] Some fatal errors occurred:
	[ERROR FileContent--proc-sys-net-bridge-bridge-nf-call-iptables]: /proc/sys/net/bridge/bridge-nf-call-iptables does not exist
	[ERROR FileContent--proc-sys-net-ipv4-ip_forward]: /proc/sys/net/ipv4/ip_forward contents are not set to 1
	[ERROR Swap]: running with swap on is not supported. Please disable swap
[preflight] If you know what you are doing, you can make a check non-fatal with `--ignore-preflight-errors=...`

如果啟用 swap 的話，當你記憶體不夠用的時候，OS 會先把暫時沒有用的資料存到硬碟裡，又稱作為 swap out。相反，OS 需要用到剛剛存在硬碟裡的資料，則會把資料再載入回記憶體裡面，又稱作為 swap in。

使用 Kubenetes 的時候需要停用 swap 這個功能：

1
swapoff -a

相關討論在 Github 的 issue 上。

上面的設定在重新開機之後就會失效 swap，要將 swap 完全關掉的話，需編輯 /etc/fstab 這個檔案，將 mount point 在 / 的項目註解掉：

1
2
# /etc/fstab
# UUID=10e56f7b-7b40-4b10-8029-642badc59ce9  /    ext4    errors=remount-ro 0       1

exec format error

由於 CPU 有分 Intel 跟 Arm 的架構，這個問題會發生是因為 Docker image files 是基於某個特定的架構。也就是說，在 Intel 上建立的 Docker file 只能在 Intel 上執行；在 Arm32 上建立的 Docker file 只能在 Arm32 上執行。

所以當你使用 kubectl logs 查看某個 pod 出現如下的錯誤時：

1
2
$ kubectl logs pod/kuard-777c5775cd-lg7kc
standard_init_linux.go:207: exec user process caused "exec format error"

確認你的 Docker image 有支援你 CPU 的架構

Stackoverflow 上的討論

Reference

在 Kubernetes Minikube 上安裝 Load Balancer MetalLB

2019-04-17

MetalLB

MetalLB 是 Bare metal Kubernetes 的 load balancer，如果原先你使用 --type=LoadBalancer 來暴露你的 port 的話，service 裡的 EXTERNAL-IP 會一直是 pending 的狀態：

1
2
3
4
$ kubectl expose deployment hello-world --type=LoadBalancer
$ kubectl get service
NAME         TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)          AGE
hello-world  LoadBalancer   10.102.80.194   <pending>      3000:31118/TCP   17m

要解決這個方法其實有很多種，你可以使用現有的雲端平台，像是 GCP、AWS 等等，這些雲端平台上都有提供 Load Balancer 的服務，當然你需要付些費用，如果要免費的話，可以自己安裝 OpenStack。

但是我們只需要 Kubernetes 的功能，卻要把整個 OpenStack 安裝好，然後只用其中的 Load Balancer 的話，這個作法實在有點殺雞焉用牛刀。

如同 GitHub 上這篇 issue 所說的，為何不單把 Load Balancer 的服務抽出來安裝就好呢，於是 MetalLB 就這樣誕生了

Installation

首先你必須先安裝好 minikube，minikube 的安裝就自行 google 了，而且還需要對 Kubernetes 的指令有一些基礎。

BGP Router UI

查看 BGP router 狀態，你可以使用網頁查看 BGP router 目前的狀態

1
kubectl apply -f https://raw.githubusercontent.com/google/metallb/v0.7.3/manifests/test-bgp-router.yaml

使用 minikube 開啟網頁：

1
minikube service -n metallb-system test-bgp-router-ui

MetalLB

安裝最重要的 Metallb，他會在 metallb-system namespace 底下產生 daemonset speaker 跟 deployment controller。

1
kubectl apply -f https://raw.githubusercontent.com/google/metallb/v0.7.3/manifests/metallb.yaml

這時候重新刷新 BGP Router UI 的話，裡面的內容會跟安裝前的不一樣。

ConfigMap

MetalLB 的設定檔是透過 Kubernetes 裡面的 config map 下去做設定的，你必須跟他講他能夠分配的 IP 池，跟一些相關設定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    peers:
    - my-asn: 64500
      peer-asn: 64500
      peer-address: 10.96.0.100
    - my-asn: 64500
      peer-asn: 64500
      peer-address: 10.96.0.101
    address-pools:
    - name: my-ip-space
      protocol: bgp
      avoid-buggy-ips: true
      addresses:
      - 198.51.100.0/24

看到後面倒數幾行

  • avoid-buggy-ips: true：代表 Load Balancer 在分配 IP 的時候，會從 .1 開始分配，而不會從 .0 開始
  • 198.51.100.0/24：Load Balancer 能分配的 IP 池

然後我們就套用這些設定吧：

1
kubectl apply -f https://raw.githubusercontent.com/google/metallb/v0.7.3/manifests/tutorial-3.yaml

檢查

來跑一些簡單的容器，然後使用 LoadBalancer 暴露它：

1
2
kubectl run hello-world --image=k8s.gcr.io/echoserver:1.10 --port=8080
kubectl expose deployment hello-world --type=LoadBalancer

使用 kubectl get service 指令查看現在 service 的狀態，可能需要等個幾秒鐘，EXTERNAL-IP 這個欄位就會是 MetalLB 從 IP 池分配給我們的 IP：

1
2
3
$ kubectl get service
NAME             TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)          AGE
hello-world      LoadBalancer   10.103.246.36   198.51.100.1   8080:31504/TCP   11s

沒有看到 pending 的話，就代表你成功了。

Reference

© 2025 Akiicat 學習筆記 - Powered by Hexo - Theme Chan